GOF23学习笔记(一)单例模式

单例模式

核心作用:

保证一个类只有一个实例,并且提供一个访问该实例的全局访问点。

单例模式的优点:

由于单例模式只生成一个实例,减少了系统性能开销,当一个对象的产生需要许多资源时,如读取配置,产生其他依赖对象时,则可以通过在应用启动时直接产生一个单例对象,然后永久驻留内存的方式来解决。

常见的五种单例模式实现方式

饿汉式(线程安全,调用效率高,但不能延时加载)

public class Singleton1 {
	//类初始化时直接加载该对象,加载类时,天然的线程安全
	private static Singleton1 instance = new Singleton1();
	//私有化构造方法
	private Singleton1() {}
	//方法没有同步,调用效率高
	public static Singleton1 getInstance() {
		return instance;
	}
}

由于对象在类加载时便被创建,如果程序运行过程中并没有使用该对象,那就造成了资源的浪费。所以我们需要一种只有当调用该对象时该对象才被创建的方式。

懒汉式(线程安全,调用效率不高,可以延时加载)

public class Singleton2 {
	//类初始化时,不加载对象,真正使用的时候再加载(延时加载)
	private static Singleton2 instance;
	//私有化构造器
	private Singleton2() {};
	//方法同步,调用效率低
	public static synchronized Singleton2 getInstance() {
		if(instance == null) {
			instance = new Singleton2();
		}
		return instance;
	}
}

资源利用率提高了,但每次调用getInstance()都要同步,并发效率低。

双重检测锁实现(由于JVM底层内部模型的原因,偶尔会出问题,不建议使用)

public class Singleton3 {
	private static Singleton3 instance = null;
	
	private Singleton3() {};
	
	public static Singleton3 getInstance() {
		if(instance == null) {
			Singleton3 sc;
			synchronized (Singleton3.class) {
				sc = instance;
				if(sc == null) {
					synchronized (Singleton3.class) {
						if(sc == null) {
							sc = new Singleton3();
						}
					}
				instance = sc;
				}
			}
		}
		return instance;
	}
}

此方法将同步的内容移动到if内部,只有第一次创建才会同步,提高了效率。但是,该方法会受到指令重排序的影响,我将在后一篇博客单独讲解...https://blog.csdn.net/icydate/article/details/80307969

静态内部类式(线程安全,调用效率高,并且能延时加载)

public class Singleton4 {
	//内部类一开始不会初始化,可以实现延时加载
	private static class SingletonClassInstance {
		private static Singleton4 instance = new Singleton4();
	}
	//私有化构造方法
	private Singleton4() {}
	//方法没有同步,调用效率高
	public static Singleton4 getInstance() {
		//内部类加载对象,天然线程安全
		return SingletonClassInstance.instance;
	}
}
兼并高效调用和延时加载的优势。

枚举单例(线程安全,调用效率高,不能延时加载)

public enum singleton5 {
	//这个枚举元素,本身就是单例对象
	INSTANCE;
	//添加自己需要的操作
	public void singletonOperate() {
		
	}
}
实现简单,枚举本身就是单例模式,由JVM从根本上提供保障。避免通过反射和反序列化的漏洞,但没有延时加载。

你可能感兴趣的:(设计模式)