189 8069 5689

双重检查锁为什么要使用volatile字段?

双重锁的由来

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

创新互联公司-专业网站定制、快速模板网站建设、高性价比铁东网站开发、企业建站全套包干低至880元,成熟完善的模板库,直接使用。一站式铁东网站制作公司更省心,省钱,快速模板网站建设找我们，业务覆盖铁东地区。费用合理售后完善，10余年实体公司更值得信赖。

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

/**
 * @author xiaoshu
 */
public class Instance {
}

/**
 * 非线程安全的延迟初始化对象
 *
 * @author xiaoshu
 */
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 xiaoshu
 */
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 xiaoshu
 */
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.初始化对象

多线程执行时序表

时间线程A线程B
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 xiaoshu
 */
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)。

/**
 * 基于类初始化的解决方案
 *
 * @author xiaoshu
 */
public class InstanceFactory {
    private static class InstanceHolder {
        private static Instance instance = new Instance();
    }

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

字段延迟初始化降低了初始化类或创建实例的开销，但增加了访问被延迟初始化的字段的开销。在大多数时候，正常的初始化要优于延迟初始化。如果确实需要对实例字段使用线程安全的延迟初始化，请使用上面介绍的基于volatile的延迟初始化的方案；如果确实需要对静态字段使用线程安全的延迟初始化，请使用上面介绍的基于类初始化的方案。


名称栏目：双重检查锁为什么要使用volatile字段?
本文地址：http://jkwzsj.com/article/pjpcdc.html

其他资讯