java双检查锁的思考

在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造成较大的执行开销。

参考

https://blog.csdn.net/li295214001/article/details/48135939/