写点什么

双重检查锁定与延迟初始化

2013 年 10 月 07 日

在 java 程序中,有时候可能需要推迟一些高开销的对象初始化操作,并且只有在使用这些对象时才进行初始化。此时程序员可能会采用延迟初始化。但要正确实现线程安全的延迟初始化需要一些技巧,否则很容易出现问题。比如,下面是非线程安全的延迟初始化对象的示例代码:

复制代码
public class UnsafeLazyInitialization {
private static Instance instance;
public static Instance getInstance() {
if (instance == null) //1:A 线程执行
instance = new Instance(); //2:B 线程执行
return instance;
}
}

在 UnsafeLazyInitialization 中,假设 A 线程执行代码 1 的同时,B 线程执行代码 2。此时,线程 A 可能会看到 instance 引用的对象还没有完成初始化(出现这种情况的原因见后文的“问题的根源”)。

对于 UnsafeLazyInitialization,我们可以对 getInstance() 做同步处理来实现线程安全的延迟初始化。示例代码如下:

复制代码
public class SafeLazyInitialization {
private static Instance instance;
public synchronized static Instance getInstance() {
if (instance == null)
instance = new Instance();
return instance;
}
}

由于对 getInstance() 做了同步处理,synchronized 将导致性能开销。如果 getInstance() 被多个线程频繁的调用,将会导致程序执行性能的下降。反之,如果 getInstance() 不会被多个线程频繁的调用,那么这个延迟初始化方案将能提供令人满意的性能。

在早期的 JVM 中,synchronized(甚至是无竞争的 synchronized)存在这巨大的性能开销。因此,人们想出了一个“聪明”的技巧:双重检查锁定(double-checked locking)。人们想通过双重检查锁定来降低同步的开销。下面是使用双重检查锁定来实现延迟初始化的示例代码:

复制代码
public class DoubleCheckedLocking { //1
private static Instance instance; //2
public static Instance getInstance() { //3
if (instance == null) { //4: 第一次检查
synchronized (DoubleCheckedLocking.class) { //5: 加锁
if (instance == null) //6: 第二次检查
instance = new Instance(); //7: 问题的根源出在这里
} //8
} //9
return instance; //10
} //11
} //12

如上面代码所示,如果第一次检查 instance 不为 null,那么就不需要执行下面的加锁和初始化操作。因此可以大幅降低 synchronized 带来的性能开销。上面代码表面上看起来,似乎两全其美:

  • 在多个线程试图在同一时间创建对象时,会通过加锁来保证只有一个线程能创建对象。
  • 在对象创建好之后,执行 getInstance() 将不需要获取锁,直接返回已创建好的对象。

双重检查锁定看起来似乎很完美,但这是一个错误的优化!在线程执行到第 4 行代码读取到 instance 不为 null 时,instance 引用的对象有可能还没有完成初始化。

问题的根源

前面的双重检查锁定示例代码的第 7 行(instance = new Singleton();)创建一个对象。这一行代码可以分解为如下的三行伪代码:

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

上面三行伪代码中的 2 和 3 之间,可能会被重排序(在一些 JIT 编译器上,这种重排序是真实发生的,详情见参考文献 1 的“Out-of-order writes”部分)。2 和 3 之间重排序之后的执行时序如下:

复制代码
memory = allocate(); //1:分配对象的内存空间
instance = memory; //3:设置 instance 指向刚分配的内存地址
// 注意,此时对象还没有被初始化!
ctorInstance(memory); //2:初始化对象

根据《The Java Language Specification, Java SE 7 Edition》(后文简称为 java 语言规范),所有线程在执行 java 程序时必须要遵守 intra-thread semantics。intra-thread semantics 保证重排序不会改变单线程内的程序执行结果。换句话来说,intra-thread semantics 允许那些在单线程内,不会改变单线程程序执行结果的重排序。上面三行伪代码的 2 和 3 之间虽然被重排序了,但这个重排序并不会违反 intra-thread semantics。这个重排序在没有改变单线程程序的执行结果的前提下,可以提高程序的执行性能。

为了更好的理解 intra-thread semantics,请看下面的示意图(假设一个线程 A 在构造对象后,立即访问这个对象):

如上图所示,只要保证 2 排在 4 的前面,即使 2 和 3 之间重排序了,也不会违反 intra-thread semantics。

下面,再让我们看看多线程并发执行的时候的情况。请看下面的示意图:

由于单线程内要遵守 intra-thread semantics,从而能保证 A 线程的程序执行结果不会被改变。但是当线程 A 和 B 按上图的时序执行时,B 线程将看到一个还没有被初始化的对象。

※注:本文统一用红色的虚箭线标识错误的读操作,用绿色的虚箭线标识正确的读操作。

回到本文的主题,DoubleCheckedLocking 示例代码的第 7 行(instance = new Singleton();)如果发生重排序,另一个并发执行的线程 B 就有可能在第 4 行判断 instance 不为 null。线程 B 接下来将访问 instance 所引用的对象,但此时这个对象可能还没有被 A 线程初始化!下面是这个场景的具体执行时序:

时间

线程 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 将会访问到一个还未初始化的对象。

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

  1. 不允许 2 和 3 重排序;
  2. 允许 2 和 3 重排序,但不允许其他线程“看到”这个重排序。

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

基于 volatile 的双重检查锁定的解决方案

对于前面的基于双重检查锁定来实现延迟初始化的方案(指 DoubleCheckedLocking 示例代码),我们只需要做一点小的修改(把 instance 声明为 volatile 型),就可以实现线程安全的延迟初始化。请看下面的示例代码:

复制代码
public class SafeDoubleCheckedLocking {
private volatile static Instance instance;
public static Instance getInstance() {
if (instance == null) {
synchronized (SafeDoubleCheckedLocking.class) {
if (instance == null)
instance = new Instance();//instance 为 volatile,现在没问题了
}
}
return instance;
}
}

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

当声明对象的引用为 volatile 后,“问题的根源”的三行伪代码中的 2 和 3 之间的重排序,在多线程环境中将会被禁止。上面示例代码将按如下的时序执行:

这个方案本质上是通过禁止上图中的 2 和 3 之间的重排序,来保证线程安全的延迟初始化。

基于类初始化的解决方案

JVM 在类的初始化阶段(即在 Class 被加载后,且被线程使用之前),会执行类的初始化。在执行类的初始化期间,JVM 会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化。

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

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

假设两个线程并发执行 getInstance(),下面是执行的示意图:

这个方案的实质是:允许“问题的根源”的三行伪代码中的 2 和 3 重排序,但不允许非构造线程(这里指线程 B)“看到”这个重排序。

初始化一个类,包括执行这个类的静态初始化和初始化在这个类中声明的静态字段。根据 java 语言规范,在首次发生下列任意一种情况时,一个类或接口类型 T 将被立即初始化:

  • T 是一个类,而且一个 T 类型的实例被创建;
  • T 是一个类,且 T 中声明的一个静态方法被调用;
  • T 中声明的一个静态字段被赋值;
  • T 中声明的一个静态字段被使用,而且这个字段不是一个常量字段;
  • T 是一个顶级类(top level class,见 java 语言规范的§7.6),而且一个断言语句嵌套在 T 内部被执行。

在 InstanceFactory 示例代码中,首次执行 getInstance() 的线程将导致 InstanceHolder 类被初始化(符合情况 4)。

由于 java 语言是多线程的,多个线程可能在同一时间尝试去初始化同一个类或接口(比如这里多个线程可能在同一时刻调用 getInstance() 来初始化 InstanceHolder 类)。因此在 java 中初始化一个类或者接口时,需要做细致的同步处理。

Java 语言规范规定,对于每一个类或接口 C,都有一个唯一的初始化锁 LC 与之对应。从 C 到 LC 的映射,由 JVM 的具体实现去自由实现。JVM 在类初始化期间会获取这个初始化锁,并且每个线程至少获取一次锁来确保这个类已经被初始化过了(事实上,java 语言规范允许 JVM 的具体实现在这里做一些优化,见后文的说明)。

对于类或接口的初始化,java 语言规范制定了精巧而复杂的类初始化处理过程。java 初始化一个类或接口的处理过程如下(这里对类初始化处理过程的说明,省略了与本文无关的部分;同时为了更好的说明类初始化过程中的同步处理机制,笔者人为的把类初始化的处理过程分为了五个阶段):

第一阶段:通过在 Class 对象上同步(即获取 Class 对象的初始化锁),来控制类或接口的初始化。这个获取锁的线程会一直等待,直到当前线程能够获取到这个初始化锁。

假设 Class 对象当前还没有被初始化(初始化状态 state 此时被标记为 state = noInitialization),且有两个线程 A 和 B 试图同时初始化这个 Class 对象。下面是对应的示意图:

下面是这个示意图的说明:

时间

线程 A

线程 B

t1

A1: 尝试获取 Class 对象的初始化锁。这里假设线程 A 获取到了初始化锁

B1: 尝试获取 Class 对象的初始化锁,由于线程 A 获取到了锁,线程 B 将一直等待获取初始化锁

t2

A2:线程 A 看到线程还未被初始化(因为读取到 state == noInitialization),线程设置 state = initializing

复制代码
t3

A3:线程 A 释放初始化锁

第二阶段:线程 A 执行类的初始化,同时线程 B 在初始化锁对应的 condition 上等待:

下面是这个示意图的说明:

时间

线程 A

线程 B

t1

A1: 执行类的静态初始化和初始化类中声明的静态字段

B1:获取到初始化锁

t2

复制代码
B2:读取到 state == initializing

t3

复制代码
B3:释放初始化锁

t4

复制代码
B4:在初始化锁的 condition 中等待

第三阶段:线程 A 设置 state = initialized,然后唤醒在 condition 中等待的所有线程:

下面是这个示意图的说明:

时间

线程 A

t1

A1:获取初始化锁

t2

A2:设置 state = initialized

t3

A3:唤醒在 condition 中等待的所有线程

t4

A4:释放初始化锁

t5

A5:线程 A 的初始化处理过程完成

第四阶段:线程 B 结束类的初始化处理:

下面是这个示意图的说明:

时间

线程 B

t1

B1:获取初始化锁

t2

B2:读取到 state == initialized

t3

B3:释放初始化锁

t4

B4:线程 B 的类初始化处理过程完成

线程 A 在第二阶段的 A1 执行类的初始化,并在第三阶段的 A4 释放初始化锁;线程 B 在第四阶段的 B1 获取同一个初始化锁,并在第四阶段的 B4 之后才开始访问这个类。根据 java 内存模型规范的锁规则,这里将存在如下的 happens-before 关系:

这个 happens-before 关系将保证:线程 A 执行类的初始化时的写入操作(执行类的静态初始化和初始化类中声明的静态字段),线程 B 一定能看到。

第五阶段:线程 C 执行类的初始化的处理:

下面是这个示意图的说明:

时间

线程 B

t1

C1:获取初始化锁

t2

C2:读取到 state == initialized

t3

C3:释放初始化锁

t4

C4:线程 C 的类初始化处理过程完成

在第三阶段之后,类已经完成了初始化。因此线程 C 在第五阶段的类初始化处理过程相对简单一些(前面的线程 A 和 B 的类初始化处理过程都经历了两次锁获取 - 锁释放,而线程 C 的类初始化处理只需要经历一次锁获取 - 锁释放)。

线程 A 在第二阶段的 A1 执行类的初始化,并在第三阶段的 A4 释放锁;线程 C 在第五阶段的 C1 获取同一个锁,并在在第五阶段的 C4 之后才开始访问这个类。根据 java 内存模型规范的锁规则,这里将存在如下的 happens-before 关系:

这个 happens-before 关系将保证:线程 A 执行类的初始化时的写入操作,线程 C 一定能看到。

※注 1:这里的 condition 和 state 标记是本文虚构出来的。Java 语言规范并没有硬性规定一定要使用 condition 和 state 标记。JVM 的具体实现只要实现类似功能即可。

※注 2:Java 语言规范允许 Java 的具体实现,优化类的初始化处理过程(对这里的第五阶段做优化),具体细节参见 java 语言规范的 12.4.2 章。

通过对比基于 volatile 的双重检查锁定的方案和基于类初始化的方案,我们会发现基于类初始化的方案的实现代码更简洁。但基于 volatile 的双重检查锁定的方案有一个额外的优势:除了可以对静态字段实现延迟初始化外,还可以对实例字段实现延迟初始化。

总结

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

参考文献

  1. Double-checked locking and the Singleton pattern
  2. The Java Language Specification, Java SE 7 Edition
  3. JSR-133: Java Memory Model and Thread Specification
  4. Java Concurrency in Practice
  5. Effective Java (2nd Edition)
  6. JSR 133 (Java Memory Model) FAQ
  7. The JSR-133 Cookbook for Compiler Writers
  8. Java theory and practice: Fixing the Java Memory Model, Part 2

个人简介

程晓明,java 软件工程师,专注于并发编程,现就职于富士通南大。个人邮箱:asst2003@163.com。


感谢方腾飞对本文的审校。

给InfoQ 中文站投稿或者参与内容翻译工作,请邮件至 editors@cn.infoq.com 。也欢迎大家通过新浪微博( @InfoQ )或者腾讯微博( @InfoQ )关注我们,并与我们的编辑和其他读者朋友交流。

2013 年 10 月 07 日 08:3031056

评论 3 条评论

发布
用户头像
写的太好了,几年前就看过这篇文章 ,现在看还是觉得写的很好~
2020 年 08 月 13 日 14:13
回复
用户头像
volatile有两个作用嘛,一个是直接读写主内存,一个是加入内存屏障。按照笔者的意思,这个用的是volatile的加入内存屏障特性,这么理解对吗
2020 年 04 月 07 日 19:36
回复
用户头像
如果对静态实例字段进行初始化,那么优选哪个实例化方式呢,理由是什么
2020 年 04 月 07 日 19:33
回复
没有更多了
  • 字段访问相关优化

    即时编译器将沿着控制流缓存字段存储、读取的值,并在接下来的字段读取操作时直接使用该缓存值。

    2018 年 9 月 14 日

  • 第 3 讲 | 谈谈 final、finally、 finalize 有什么不同?

    Java语言有很多看起来很相似,但是用途却完全不同的语言要素。

    2018 年 5 月 10 日

  • JVM 内存回收理论与实现

    在上一篇《HotSpot虚拟机对象探秘》中,我们讨论了在HotSpot里对象是如何创建的、有怎样的内存布局、如何查找和使用。在本篇中,我们将继续探讨虚拟机自动内存管理系统的最重要一块职能:虚拟机如何对死亡的对象进行内存回收。

  • 关于实时 Java 的系列文章

    Sun开发者网络登载了一篇关于实时Java系统的文章。该文章由两部分组成,内容覆盖线程、内存和垃圾回收等问题,并对Sun Java RTS平台进行了介绍。

  • 深入理解 Java 内存模型(二)——重排序

    Java线程之间的通信对程序员完全透明,内存可见性问题很容易困扰Java程序员,本文试图揭开Java内存模型神秘的面纱。本文大致分三部分:重排序与顺序一致性;三个同步原语(lock,volatile,final)的内存语义,重排序规则及在处理器中的实现;Java内存模型的设计目标,及其与处理器内存模型和顺序一致性内存模型的关系。

  • 话说 线程的概念 & 生命周期

    线程概念 线程生命周期

    2021 年 4 月 5 日

  • 深入理解 Java 内存模型(六)——final

    StartFragmentJava线程之间的通信对程序员完全透明,内存可见性问题很容易困扰Java程序员,本文试图揭开Java内存模型神秘的面纱。本文大致分三部分:重排序与顺序一致性;三个同步原语(lock,volatile,final)的内存语义,重排序规则及在处理器中的实现;Java内存模型的设计目标,及其与处理器内存模型和顺序一致性内存模型的关系。

  • 案例分析(四):高性能数据库连接池 HiKariCP

    HiKariCP号称业界跑得最快的数据库连接池。FastList和ConcurrentBag这两个数据结构使用得很巧妙。

    2019 年 6 月 1 日

  • 逃逸分析

    即时编译器判断对象逃逸的依据有两个:一是看对象是否被存入堆中,二是看对象是否作为方法调用的调用者或者参数。

    2018 年 9 月 12 日

  • 一文讲清 JVM 内存结构 | 极客视点

    一直都是程序员面试的必考点,但是要把它搞清楚又好像不是特别容易。的知识点太散,不系统,所以不便于归纳总结。

  • Java 深度历险(三)——Java 线程​:基本概念、可见性与同步

    对于Java来说,在语言内部提供了线程的支持。但是Java的多线程应用开发会遇到很多问题。首先是很难编写正确,其次是很难测试是否正确,最后是出现问题时很难调试。一个多线程应用可能运行了好几天都没问题,然后突然就出现了问题,之后却又无法再次重现出来。如果在正确性之外,还需要考虑应用的吞吐量和性能优化的话,就会更加复杂。本文主要介绍Java中的线程的基本概念、可见性和线程同步相关的内容。

  • 享元模式(下):剖析享元模式在 Java Integer、String 中的应用

    除非经过线上验证,利用享元模式真的可以大大节省内存,否则就不要过度使用这个模式。

    2020 年 3 月 9 日

  • 十个问题弄清 JVM&GC(一)

    每个java开发同学不管是日常工作中还是面试里,都会遇到JDK、JVM和GC的问题。本文会从以下10个问题为切入点,带着大家一起全面了解一下JVM的方方面面。

  • 安全性、活跃性以及性能问题

    并发编程是一个复杂的技术领域,微观上涉及到原子性问题、可见性问题和有序性问题,宏观则表现为安全性、活跃性以及性能问题。

    2019 年 3 月 14 日

  • 文章:Java 6 中的线程优化真的有效么?

    像偏向锁、锁粗化、通过逸出分析的锁省略以及自适应的自旋锁等技术,都是为了提高并发性而出现的。它们允许应用程序线程之间可以更多更高效地共享数据。但是它们真的有效么?在这篇由两部分组成的文章里,Jeroen Borgers将逐一探究这些特性,并尝试在单一线程基准的协助下,回答关于性能的问题。<a href="http://www.infoq.com/cn/articles/java-threading-optimizations-p1" target="_blank">直接点击阅读完整文章</a>。

  • Netty 系列之 Netty 并发编程分析

    Java技术领域,网络通信和多线程并发编程是相对较高级和难掌握的领域,作为高性能的NIO通信框架,线程模型对Netty的性能影响非常大,Netty的高性能是建立在灵活和高效的并发编程基础之上。通过学习Netty的多线程并发编程技巧,对于我们掌握并在实践中灵活应用Java多线程编程来提升系统性能带来很大的帮助。

  • 深入理解 Java 内存模型(三)——顺序一致性

    Java线程之间的通信对程序员完全透明,内存可见性问题很容易困扰Java程序员,本文试图揭开Java内存模型神秘的面纱。本文大致分三部分:重排序与顺序一致性;三个同步原语(lock,volatile,final)的内存语义,重排序规则及在处理器中的实现;Java内存模型的设计目标,及其与处理器内存模型和顺序一致性内存模型的关系。

发现更多内容

阿里内部首发Spring Cloud全套微服务架构笔记,速拿去怼面试官!

Java架构追梦

Java 编程 面试 微服务架构 SpringCloud

云小课|云数据库RDS实例连接失败了?送你7大妙招轻松应对

华为云开发者社区

数据库 网络 ssl RDS实例 端口

Java程序员必会的三个技能:Spring+MySQL+并发编程

Java架构师迁哥

架构师训练营 1 期第 6 周:技术选型(二) - 作业

piercebn

极客大学架构师训练营

架构师训练营第二周作业

邢永春

Double Kill!! 数据联邦修炼之路

脑极体

使用抓包工具fiddler和apipost进行接口测试

测试人生路

测试工具 fiddler

架构训练营-week6-作业

于成龙

CAP 架构训练营

一整套Java线上故障排查技巧,爱了!爱了!

互联网架构师小马

全网首发,做第一人纯源码讲解RabbitMQ实践,收藏吧

小Q

Java 学习 架构 面试 RabbitMQ

RabbitMQ之路由和通配符模式,附源码注释讲解

小Q

Java 学习 架构 面试 RabbitMQ

钻石与小度:智能语音助手背后的“马斯洛需求模型”

脑极体

玩转华为云开发|老板万万没想到:刚入职的我一人就搞定人脸识别开发

华为云开发者社区

软件开发 模块化流程 人脸识别 API 华为云

渣渣2本学历CRUD一年半,决定改变现状,努力学习两个月成功拿到美团30k offer

Java架构之路

Java 程序员 架构 面试 编程语言

架构师训练营第六周课后练习

薛凯

架构师训练营 W02 作业

Geek_f06ede

架构师训练

写时复制集合 —— CopyOnWriteArrayList

程序员小航

Java 源码 并发 源码阅读 JUC

CAP 原理

黄立

CAP

第1周 架构方法-作业

SuGeek

架构师训练营 W02 总结

Geek_f06ede

架构师训练

作业一:

丁乐洪

牛皮!GitHub上标星90.6K的Java面试指南+笔记

互联网架构师小马

Java GitHub 学习 程序员 面试

架构训练营-week6-学习总结-技术选型(二)

于成龙

架构训练营

从一个HTTP请求来读懂HTTP、TCP协议

互联网架构师小马

十八般武艺玩转GaussDB(DWS)性能调优(二):坏味道SQL识别

华为云开发者社区

数据库 sql 性能调优 GaussDB 算子

三分钟带你分清Mysql 和Oracle之间的误区

华为云开发者社区

MySQL 数据库 oracle 安全 关系型数据库

牛皮了!字节面试官爆肝七天七夜总结了一份算法面试笔记

互联网架构师小马

Java 程序员 字节跳动 面试 算法

阿里五位MySQL封神大佬耗17个月总结出53章性能优化法则

996小迁

Java MySQL 大数据 架构 面试

Mysql中,这21个写SQL的好习惯,你值得拥有呀

捡田螺的小男孩

MySQL sql SQL优化 sql习惯

架构师训练营第 1 期第 6 周作业

好吃不贵

极客大学架构师训练营

架构师训练营第 1 期第 6 周学习总结

好吃不贵

极客大学架构师训练营

2021 ThoughtWorks 技术雷达峰会

2021 ThoughtWorks 技术雷达峰会

双重检查锁定与延迟初始化-InfoQ