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 singletonDemoAtomicReference = new AtomicReference();
    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/

你可能感兴趣的:(java双检查锁的思考)