Java volatile 原理解析

用volatile修饰的变量能够保证其对所有线程的可见性，要理解这一点，我们首先需要了解Java的内存模型。

1.Java内存模型

Java内存模型分为主内存和工作内存。

主内存是对所有线程所共享的，此外每个线程有自己的工作内存，工作内存不共享。

线程在工作时，从主内存中拷贝所需变量到自己的工作内存中。

线程对变量的所有操作，都必须在工作内存中进行，不能直接操作主存中的变量，也不能直接访问其他线程的工作内存。

线程间变量值的传递需要通过主内存进行，何时将工作内存中的变量同步到主内存，由 JVM 控制。

Java 内存模型

基于此种内存模型，在多线程中会产生脏读，即读到非最新的数据。

譬如，有1个共享变量：

int i = 0;

线程A和线程B同时执行以下操作：

i++;

我们期望的结果为 2，但实际结果可能为 1 也可能是 2。

我们分析一下线程的执行过程：首先从主内存中拷贝 变量i 到自己的工作内存，对工作内存中的 变量i 副本进行 +1 操作，将 i 的最新值写入到主内存中。

当 2 个线程同时执行上述代码时，可能存在以下一种情况：线程A从主存中读取了 变量i 到工作内存中，并对 i 进行 +1 操作。在线程A将最新值 i=1 写入到主存前，此时线程B从主存中读取了 变量i，此时 i 仍为 0。线程A、B分别将操作后的 变量i 的值同步到主存，最终在主存中 i = 1。

在上述例子中，线程A和B的工作内存是相互隔离、不可访问的，即不可见。

那么 volatile 能实现的可见性是什么呢，是能让1个线程的工作内存变成共享的吗？并非如此，我们看下 Java中可见性的定义。

2. Java 中的可见性

可见性是指当一个线程修改共享变量，其他线程下次读取到的将是该共享变量的最新值。

上文说到线程的工作内存对其他线程是隔离的，那么如何保证其他线程读到的是最新值呢？

事实上，当一个共享变量用 volatile 关键字修饰时，它会保证修改的值会被立即更新到主存中，同时其他线程的工作内存中该共享变量的缓存将失效，当线程下次读取该变量时，将强制主存中读取最新值。

接下来从硬件的角度，简要说下 volatile 的实现原理。

3. volatile 实现原理

Java 虚拟机规范定义了 Java 内存模型来屏蔽掉各种硬件和操作系统的内存差异。

但是为了实现更好的执行性能，Java 内存模型没有限制执行引擎使用CPU的特定缓存器或缓存来和主内存交互。

为方便理解，我们将 Java 内存模型中的主内存类比为 RAM（系统内存），工作内存类比为 CPU的高速缓存。

实际上，工作内存并非独立存在的一段内存空间，它是对CPU的寄存器、高速缓存及其他硬件的抽象描述。

我们看下 CPU 和 系统内存间的交互：

CPU 和主内存交互示意图

对于多核心处理器，每个处理器都有自己的高速缓存，用于缓存计算中间结果。当不同核心上执行的运算任务涉及到同一块内存区域时，就有可能出现缓存不一致的问题。

我们看看 Java 虚拟机是如何解决这个问题的，当对用 volatile 修饰的变量进行了写操作时，JVM 会向 CPU 发送一条 Lock 前缀的指令，该指令将做以下2件事情：

• 将 CPU 高速缓存中的数据写回到系统内存；

• 如果其他 CPU 核心缓存了该数据，将其置为失效。

其中 操作2 是通过缓存一致性协议实现的： 每个处理器通过嗅探在总线上传播的数据，检查自己缓存中的数据是否过期，当处理器发现高速缓存中的数据对应的内存地址被修改，会将该缓存数据置为失效，当处理器下次访问该内存地址数据时，将强制重新从系统内存中读取。

4. volatile 的使用说明

我们已经解释了 volatile 的实现原理和作用，那么它能避免文章开头提到的脏读问题吗？答案是并不能，原因是 volatile 不能实现原子性操作。

原子性操作是不可再拆分的操作，要么执行，要么不执行。

原子操作不会被线程调度机制打断，不需要 synchronized。

i++ 虽然仅包含一行语句，但实际上它进行了 3 项操作：

1. 从内存中读取 i 的至；

2. 对 i 进行 +1 操作

3. 将 i 的新值写入到内存中。

即便 volatile 能够保证 线程A 进行了 i+1 操作后，i 的新值将被立即更新到主存。但在 i 写入到主存前，可能线程B已经读取了 i 值，此时 i 仍为 0。

在线程A 将 i 的新值写到主存后，线程B 的工作内存中 i 的缓存将失效，但此时线程B已无需再读取 i 值。所以两次 +1 操作后最终 i=1。

执行以下代码能证明上文这一点：

执行多次，发现控制台打印的 i 值总是小于预期结果 10 * 1000 = 10000.

若要达到预期效果，则必须让 i++变为原子操作，这就需要通过 synchronized 实现，将 inc() 函数改为：

则每次执行结果都为 10000.

由于 volatile 无法保证操作的原子性，在多线程场景下使用 volatile 需要保证以下2点：

1. 对变量的写操作不依赖于当前值；

2. 该变量不会与其他变量被一起纳入到不变性条件中（譬如下界 = 上界）。

下面举几个应用场景：

用作状态标记

在 shutdown() 方法中，shutdownFlag = true 的赋值操作，与 shutdownFlag的当前值无关。而上文中的 i++ 操作，i 的新值依赖于当前值。

双重检查

在1个线程执行完语句 instance = new Singleton();后，等待在同步锁外的其他线程在判断 if (instance == null)时，会重新从主存中读取 instance 变量，从而发现其已构造完毕，方法实现了单例模式。