面试官：双重检查锁为什么要使用 volatile 字段?

待我称王封你为后i 2022-10-07 15:51 156阅读 0赞

点击上方蓝色“石杉的架构笔记”，选择“设为星标”
    
    回复“PDF”获取独家整理的学习资料！

![65994f8c082b0fc5a5e24af6d47cc339.png][]

**![24605ca66cafb1cc3fe20fbbee3d3ec7.png][]**

![9a551e95ce6eb71e120a85476b8583a8.png][]

长按扫描上方一元购买

![f3d2486e2d321ceb429c7b33852b9d75.png][]

### 双重锁的由来 ###

单例模式中，有一个DCL(双重锁)的实现方式。在Java程序中，有时候可能需要推迟一些高开销的对象初始化操作，并且只有在使用这些对象时才开始初始化。

下面是非线程安全的延迟初始化对象的实例代码。

/**
     * @author
     */
    public class Instance {
    }
    /**
     * 非线程安全的延迟初始化对象
     *
     * @author
     */
    public class UnsafeLazyInitialization {
        private static Instance instance;
        public static Instance getInstance() {
            if (null == instance) {
                instance = new Instance();
            }
            return instance;
        }
    }

在UnsafeLazyInitialization类中，假设A线程执行代码1的同时，B线程执行代码2。此时，线程A可能会看到instance引用对象还没有完成初始化。

对于UnsafeLazyInitialization类，我们可以对getInstance()方法做同步处理来实现线程安全的延迟初始化。

示例代码如下。

/**
     * 安全的延迟初始化
     *
     * @author
     */
    public class SafeLazyInitialization {
        private static Instance instance;
        public synchronized static Instance getInstance() {
            if (null == instance) {
                instance = new Instance();
            }
            return instance;
        }
    }

由于对getInstance()方法做了同步处理，synchronized将导致性能开销。如果getInstance()方法被多个线程频繁的调用，将会导致程序执行性能的下降。

反之，如果getInstance()方法不会被多个线程频繁的调用，那么这个延迟初始化方案将能提供令人满意的性能。

后来，提出了一个“聪明”的技巧：双重检查锁定（Double-Checked Locking)。想通过双重检查锁定来降低同步的开销。

下面是使用双重检查锁定来实现延迟初始化的实例代码。

/**
     * 双重检查锁定
     *
     * @author
     */
    public class DoubleCheckedLocking {
        private static Instance instance;
        public static Instance getInstance() {
            if (null == instance) {                             //1.第一次检查
                synchronized (DoubleCheckedLocking.class) {     //2.加锁
                    if (null == instance) {                     //3：第二次检查
                        instance = new Instance();              //4.问题的根源出在这里
                    }
                }
            }
            return instance;
        }
    }

双重检查锁定看起来似乎很完美，但这是一个错误的优化！

在线程执行到第1处，代码读取到instance不为null时，instance引用的对象有可能还没有完成初始化。

### 问题的根源 ###

前面的双重检查锁定实例代码的第4处（instance = new Instance();)创建了一个对象。这一行代码可以分解为如下的3行伪代码。

memory = allocate(); //1.分配对象的内存空间
    ctorInstance(memory); //2.初始化对象
    instance = memory; //3.设置instance指向刚分配的内存地址

上面3行伪代码中的2和3之间，可能会被重排序（在一些JIT编译器上，这种重排序是真实发生的），2和3之间重排序之后的执行时序如下：

memory = allocate(); //1.分配对象的内存空间
    instance = memory; //3.设置instance指向刚分配的内存地址
                                                //注意，此时对象还没有被初始化！
    ctorInstance(memory); //2.初始化对象

多线程执行时序表

*  T1 A1:分配对象的内存空间
 *  T2 A3:设置instance指向内存空间
 *  T3 B1:判断instance是否为空
 *  T4 B2:由于instance不为null，线程B将访问instance引用的对象
 *  T5 A2:初始化对象
 *  T6 A4:访问instance引用的对象

在知晓了问题发生的根源之后，我们可以想出两个方法来实现线程安全的延迟初始化。

**1）**不允许2和3重排序**2）**允许2和3重排序，但不允许其他线程“看到”这个重排序。

后文介绍的两个解决方案，分别对应于上面这两点。

### 解决方案一 ###

基于volatile的解决方案

/**
     * 安全的双重检查锁定
     *
     * @author
     */
    public class SafeDoubleCheckedLocking {
        private volatile static Instance instance;
        public static Instance getInstance() {
            if (null == instance) {
                synchronized (SafeDoubleCheckedLocking.class) {
                    if (null == instance) {
                        instance = new Instance();//instance为volatile，现在没有问题了。
                    }
                }
            }
            return instance;
        }
    }

注意：这个解决方案需要JDK5或更高版本（因为从JDK5开始使用新的JSR-133内存模型规范，这个规范增强了volatile的语义）。

当声明对象的引用为volatile后，3行伪代码中的2和3之间的重排序，在多线程环境中将会被禁止。

### 解决方案二 ###

基于类初始化的解决方案

JVM在类的初始化阶段（即在Class被加载后，且被线程使用之前），会执行类的初始化。

在执行类的初始化期间，JVM会去获取一个锁.这个锁可以同步多个线程对同一个类的初始化。

基于这个特性，可以实现另一种线程安全的延迟初始化方案（这个方案被称之为Initialization On Demand Holder idiom)。

public class InstanceFactory {
        private static class InstanceHolder {
            private static Instance instance = new Instance();
        }
        public static Instance getInstance() {
            return InstanceHolder.instance; //这里将导致InstanceHolder类被初始化
        }
    }

字段延迟初始化降低了初始化类或创建实例的开销，但增加了访问被延迟初始化的字段的开销。

在大多数时候，正常的初始化要优于延迟初始化。如果确实需要对实例字段使用线程安全的延迟初始化，请使用上面介绍的基于volatile的延迟初始化的方案；如果确实需要对静态字段使用线程安全的延迟初始化，请使用上面介绍的基于类初始化的方案。

**End**

作者：老男孩

来源：

https://blog.51cto.com/14230003/2454764

本文版权归作者所有

![f6f6c83e81c4ecb12a5cfe80017a5274.png][]

[65994f8c082b0fc5a5e24af6d47cc339.png]: /images/20221005/b4a187a12d8f4ed39c0444bbb035eecd.png
[24605ca66cafb1cc3fe20fbbee3d3ec7.png]: /images/20221005/bfad3b721ec7475faa79bba6a5031872.png
[9a551e95ce6eb71e120a85476b8583a8.png]: /images/20221005/6fa9c4b62a6e4ca1a79961959d1ab028.png
[f3d2486e2d321ceb429c7b33852b9d75.png]: /images/20221005/79d0e9892489441e999f76ad41bb43bc.png
[f6f6c83e81c4ecb12a5cfe80017a5274.png]: /images/20221005/feb3348c31214a81961e38da05130fd3.png