单例模式

面试中经常被问到各种设计模式 - 单例模式

1、懒汉式单例( 线程非安全 )

顾名思义，就是使用时才去创建实例
存在隐患：多线程情况下可能会导致实例被多次创建

public class Singleton{
	private static Singleton(){}

	private static Singleton instance = null;

	public static Singleton getSingleton(){
		if(null == instance){ //非空判断，使用时创建实例
			instance = new Singleton();
		}
	}
}

2、懒汉式单例+ 双重锁校验( 线程非安全 )

加上 synchornized 同步锁🔐，看似解决了线程安全问题，其实实际情况中还可能会出现线程非安全的问题。

public class Singleton{
	private static Singleton(){}
	private static Singleton instance = null;

	public static Singleton getSingleton(){
		if(null == instance){
			synchronized(Singleton.class){
				if(null == instance){
					instance = new Singleton();
				}
			}
		}
		return instance;
	}
}

线程A、B同时进入 getInstance() 方法，
>> 理想情况：
线程B 走到 if( null == instance ) 的判断逻辑 
这时候 线程A执行到 return instance ，instance 已经被实例完成，不为null ，if判断返回false;
线程B 走到 if( null == instance ) 的判断逻辑 ，instance还未被创建，if判断为 true，线程B进入单例的实例创建逻辑。

>> 现实情况：
java中 instance = new Singleton(); 这行代码在JVM 中会被编译成指令如下：

step1:  memory = allocate();  //分配对象的内存空间
step2:  ctorInstance(memory); //初始化对象
step3:  instance = memory;     //实例指向分配的内存空间

以上指令执行的顺序在JVM中并非一直不变，可能会经过JVM和CPU的优化进行指令重排，导致执行顺序变化，返回的结果并不是预期的实例。
所以请见下方第三种单例的实现方式，volatile关键字来防止JVM指令重排。

3、懒汉式单例+ 双重锁校验 + volatile(线程安全)

public class Singleton{
	private static Singleton(){}
	private volatile static Singleton instance = null;

	public static Singleton getSingleton(){
		if(null == instance){
			synchronized(Singleton.class){
				if(null == instance){
					instance = new Singleton();
				}
			}
		}
		return instance;
	}
}

关于volatile关键字：
一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：
1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
2）禁止进行指令重排序。
需要详细了解的可自行查资料，这里不再展开。

静态内部类实现单例(线程安全)

public class Singleton{
	private class lazyHolder{
		private static final Singleton INSTANCE = new Singleton();
	}
	private class Singleton(){}

	public static Singleton getInstance(){
		return lazyHolder.INSTANCE;
	}
}

静态内部类的实现方式 利用了 classloader的加载机制实现懒加载，防止线程安全问题。

借鉴自小灰漫画，更详细内容请去"程序员小灰"公众号。

---