在java程序中，有时候可能需要推迟一些高开销的对象初始化操作，并且只有在使用这些对象时才进行初始化。此时程序员可能会采用延迟初始化，这时候就有了创建单例的模式。
非线程安全的延迟初始化
public class SingletonDemo {
private static SingletonDemo singletonDemo;
public static SingletonDemo getInstance(){
if(singletonDemo == null){ //1行
singletonDemo = new SingletonDemo(); //2行
}
return singletonDemo;
}
}
非线程安全的单例加载会导致在高并发下，A线程执行到2行时，还没有创建成功，B线程执行到1时发现singleton == null,就进来创建，导致了对象的重复创建。而且在重排序情况下，可能导致A线程创建对象还没成功，B就引用了一个空对象，这个下面讲解
线程安全的延迟初始化
public class SingletonDemo {
private static SingletonDemo singletonDemo;
public synchronized static SingletonDemo getInstance(){
if(singletonDemo == null){ //1行
singletonDemo = new SingletonDemo(); //2行
}
return singletonDemo;
}
}
线程安全的单例模式解决了对象重复创建的问题，但是在高并发下，频繁调用getInstance()方法都需要加锁，导致了性能的下降。
双重检查锁定
public class SingletonDemo {
private static SingletonDemo singletonDemo;
public static SingletonDemo getInstance(){
if(singletonDemo == null){ //4.第一次检查
synchronized (SingletonDemo.class){ //5.加锁
if(singletonDemo == null){ //6.第二次检查
singletonDemo = new SingletonDemo(); //7.new对象
}
}
}
return singletonDemo;
}
}
双重检查锁定解决了:
- 在多个线程试图在同一时间创建对象时，会通过加锁来保证只有一个线程能创建对象
- 在对象创建好之后，执行getInstance()将不需要获取锁，直接返回已创建好的对象，保证了性能
但是
上面的双重检查锁定还是会存在问题:
在线程执行到第4行代码读取到instance不为null时，instance引用的对象有可能还没有完成初始化。
问题的根源
前面的双重检查锁定示例代码的第7行（singletonDemo = new SingletonDemo();）创建一个对象。这一行代码可以分解为如下的三行伪代码
memory = allocate(); //1：分配对象的内存空间
ctorInstance(memory); //2：初始化对象
instance = memory; //3：设置instance指向刚分配的内存地址
上面三行伪代码中的2和3之间，可能会被重排序,变成
memory = allocate(); //1：分配对象的内存空间
instance = memory; //3：设置instance指向刚分配的内存地址
//注意，此时对象还没有被初始化！
ctorInstance(memory); //2：初始化对象
所以执行的顺序可能是:
| 时间 | 线程A | 线程B |
|---|---|---|
| t1 | A1：分配对象的内存空间 | |
| t2 | A3：设置instance指向内存空间 | |
| t3 | B1：判断instance是否为空 | |
| t4 | B2：由于instance不为null，线程B将访问instance引用的对象 | |
| t5 | A2：初始化对象 | |
| t6 | A4：访问instance引用的对象 |
这里A2和A3虽然重排序了，但java内存模型的intra-thread semantics将确保A2一定会排在A4前面执行。因此线程A的intra-thread semantics没有改变。但A2和A3的重排序，将导致线程B在B1处判断出instance不为空，线程B接下来将访问instance引用的对象。此时，线程B将会访问到一个还未初始化的对象
基于volatile的双重检查锁定的解决方案（把instance声明为volatile型）
public class SingletonDemo {
private static volatile SingletonDemo singletonDemo;
public static SingletonDemo getInstance(){
if(singletonDemo == null){ //4.第一次检查
synchronized (SingletonDemo.class){ //5.加锁
if(singletonDemo == null){ //6.第二次检查
singletonDemo = new SingletonDemo(); //7.new对象
}
}
}
return singletonDemo;
}
}
volatite保证了多线程环境下行伪代码中的2和3之间的重排序被禁止。
(不懂volatite可以看Java多线程干货系列—（四）volatile关键字)
基于类初始化的解决方案
public class InstanceFactory {
private static class InstanceHolder {
public static Instance instance = new Instance();
}
public static Instance getInstance() {
return InstanceHolder.instance ; //这里将导致InstanceHolder类被初始化
}
}
基于CAS的单例模式
private static AtomicReference<SingletonDemo> singletonDemoAtomicReference = new AtomicReference<SingletonDemo>();
public static SingletonDemo getInstanceByCAS(){
for(;;){
SingletonDemo singletonDemo = singletonDemoAtomicReference.get();
if(singletonDemo != null){
return singletonDemo;
}
singletonDemo = new SingletonDemo();
if(singletonDemoAtomicReference.compareAndSet(null,singletonDemo)){
return singletonDemo;
}
}
}
用CAS的好处在于不需要使用传统的锁机制来保证线程安全,CAS是一种基于忙等待的算法,依赖底层硬件的实现,相对于锁它没有线程切换和阻塞的额外消耗,可以支持较大的并行度。CAS的一个重要缺点在于如果忙等待一直执行不成功(一直在死循环中),会对CPU造成较大的执行开销。
