1. DCL 的目标

Double Check Lock 是多线程环境下为进步提早初始化效率而被宽泛应用的一种形式。咱们经常会应用提早初始化，以升高服务启动工夫。

/** * code 1.1 */@NotThreadSafepublic class Client {  private LazyInitClass instance ;  public LazyInitClass getInstance() {    if(instance == null)      instance = new LazyInitClass("LazyInitClassFieldName") ;    return instance ;  }}

代码

下面的代码是典型的提早初始化的例子。当下面的例子裸露在多线程环境下时，便会呈现各种问题。最显著的谬误：办法会返回多个 LazyInitClass 对象。

/** * code 1.2 */@NotThreadSafepublic class Client {    private LazyInitClass instance ;    public synchronized LazyInitClass getInstance() {        if(instance == null)            instance = new LazyInitClass("LazyInitClassFieldName") ;        return instance ;    }}

代码

下面的代码在办法层面应用了 synchronized 关键字，每次调用 getInstance 办法都进行同步，确实能够无效防止多线程环境下屡次调用 getInstance 失去不同的 LazyInitClass 对象。但当 instance 初始化实现后，同步便没有了意义。同步则成为影响 getInstance 性能的要害。有没有一种办法，能够在初始化时进行正确的同步，初始化实现后又防止同步呢？于是 DCL 呈现了。

/** * code 1.3 */@NotThreadSafepublic class Client {    private LazyInitClass instance ;    public LazyInitClass getInstance() {        if(instance == null){            synchronized(this){                if(instance == null){                    instance = new LazyInitClass("LazyInitClassFieldName") ;                }            }        }        return instance ;    }}

代码

很可怜，上述代码在编译器优化、多处理器共享内存的状况下，并不能失常工作。

LazyInitClass 代码如下：

/** * code 1.4 */@NotThreadSafepublic class LazyInitClass {    private String lazyInitClassField ;    public LazyInitClass(String lazyInitClassField) {        this.lazyInitClassField = lazyInitClassField ;    }}

代码

2. DCL 存在的问题

LazyInitClass 实例写入 instance field，与 LazyInitClass 对象外部 lazyInitClassField 对象的初始化两步操作将会呈现有序性问题。（具体的有序性形容能够浏览上一篇文章：《Java 并发系列（一）：多线程三大个性》）

具体表现为：某一线程调用 getInstance 办法后，将失去一个非空的 instance 对象，但却只能看到 lazyInitClassField 的默认值，即：lazyInitClassField 为空字符串，而非构造方法中传入的LazyInitClassFieldName。

3. 使 DCL 失常工作

3.1 JDK 1.3 当前（蕴含 JDK 1.3）的解决方案

/** * code 3.1 */@ThreadSafeclass Client {         private final ThreadLocal perThreadInstance = new ThreadLocal();         private LazyInitClass instance ;         public LazyInitClass getInstance() {             if (perThreadInstance.get() == null) createInstance();             return instance;         }         private void createInstance() {             synchronized(this) {                 if (instance == null)                     instance = new LazyInitClass("LazyInitClassFieldName");             }             perThreadInstance.set(perThreadInstance);         }    }

代码

3.2 JDK 1.5 当前（蕴含 JDK 1.5）的解决方案

从 JDK5 开始，Java Memory Model 降级，volatile 关键字便能够保障可见性与有序性。

要使 DCL 失常工作，多了一种更为不便的解决方案：

/** * code 3.2 */@ThreadSafepublic class Client {    private volatile LazyInitClass instance ;    public LazyInitClass getInstance() {        if(instance == null){            synchronized(this){                if(instance == null){                    instance = new LazyInitClass("LazyInitClassFieldName") ;                }            }        }        return instance ;    }}

代码

3.3 JDK 1.3 以前（不蕴含 JDK 1.3）的解决方案

因为 JDK1.2 版本，ThreadLocal 十分慢，所以 JDK 1.2 并不举荐应用 ThreadLocal 解决 DCL 问题。所以 JDK1.3 版本以前，DCL 并没有解决方案。

3.4 不可变对象

/** * code 3.4 */@ThreadSafepublic class ImmutableLazyInitClass {    private final String lazyInitClassField ;    public ImmutableLazyInitClass(String lazyInitClassField) {        this.lazyInitClassField = lazyInitClassField ;    }}

代码

如果 LazyInitClass 对象是不可变对象，则不应用 volatile 关键字 DCL 也能失常工作（code 1.3 所示）。这是由 Java 内存模型中，final 域的非凡语义保障的：final 域能确保初始化过程的安全性，从而能够不受限制地拜访不可变对象，并在共享这些对象时毋庸同步。

4. DCL 的代替计划

/** * code 4.1 */@ThreadSafepublic class Client {    private static class LazyInitClassHolder {      static LazyInitClass singleton = new LazyInitClass("LazyInitClassFieldName");  }    public static LazyInitClass getInstance() {        return LazyInitClassHolder.singleton ;    }}

代码

这种形式被称为提早初始化占位类模式，由 Java 语义保障：只有调用了 getInstance 办法后，LazyInitClassHolder.singleton 才会被初始化。所以此形式能完满代替 DCL。

5. 总结

DCL 的应用形式曾经被宽泛废除。DCL 之所以呈现是因为无竞争同步的执行速度很慢，以及 JVM 启动很慢。但这两个问题曾经不复存在，因此它并不是一种高效的优化措施。提早初始化占位类模式能带来雷同的劣势，并更容易了解。

6. 参考资料

  • 《The "Double-Checked Locking is Broken" Declaration》：https://www.cs.umd.edu/~pugh/...
  • 《Performance of techniques for correctly implementing lazy initialization》：https://www.cs.umd.edu/~pugh/...
  • 《The volatile keyword in Java》：https://www.javamex.com/tutor...
  • 《The volatile keyword in Java 5》：https://www.javamex.com/tutor...
  • 《Java Concurrency in Practice》作者：Brain Goetz、Tim Peierls、Joshua Bloch、Joseph Bowbeer、David Holmes、Doug Lea