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.youkuaiyun.com/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从根本上提供保障。避免通过反射和反序列化的漏洞，但没有延时加载。