Java 并发系列（二）：DCL — Double Check Lock

关注

发布于: 2021 年 03 月 29 日

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》
《Performance of techniques for correctly implementing lazy initialization》
《The volatile keyword in Java》
《The volatile keyword in Java 5》
《Java Concurrency in Practice》作者：Brain Goetz、Tim Peierls、Joshua Bloch、Joseph Bowbeer、David Holmes、Doug Lea

发布于: 2021 年 03 月 29 日阅读数: 13

原文链接:【http://xie.infoq.cn/article/a568a554b746b318c68e6e7ac】。文章转载请联系作者。

TroyLiu

关注

Just Do It. 2015.09.01 加入

2012 年工作，一直从事 Java 开发。对多线程与设计模式有自己的理解。热爱技术、喜欢的语言：Java、Golang、Perl。对 VIM 比较偏爱。使用 Dvorak 键盘。

发布

暂无评论

创作场景

Java 并发系列（二）：DCL — Double Check Lock

1. DCL 的目的

2. DCL 存在的问题

3. 使 DCL 正常工作

3.1 JDK 1.3 以后（包含 JDK 1.3）的解决方案

3.2 JDK 1.5 以后（包含 JDK 1.5）的解决方案

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

3.4 不可变对象

4. DCL 的替代方案

5. 总结

6. 参考资料

TroyLiu

评论