一、概念

volatile 是 Java 中的关键字，是一个变量修饰符，被用来修饰会被不同线程访问和修改的变量。

二、volatile 作用

1. 可见性

可见性是指多个线程访问同一个变量时，其中一个线程修改了该变量的值，其它线程能够立即看到修改的值。

在 Java 内存模型中，所有的变量都存储在主存中，同时每个线程都拥有自己的工作线程，用于提高访问速度。线程会从主存中拷贝变量值到自己的工作内存中，然后在自己的工作线程中操作变量，而不是直接操作主存中的变量，由于每个线程在自己的内存中都有一个变量的拷贝，就会造成变量值不一致的问题。

如下面的代码所示：

测试类：

class VolatileTestObj { private String value = null; private boolean hasNewValue = false; public void put(String value) { while (hasNewValue) { // 等待，防止重复赋值 } this.value = value; hasNewValue = true; } public String get() { while (!hasNewValue) { // 等待，防止获取到旧值 } String value = this.value; hasNewValue = false; return value; } }

测试代码：

public class VolatileTest { public static void main(String... args) { VolatileTestObj obj = new VolatileTestObj(); new Thread(() -> { while (true) { obj.put("time：" + System.currentTimeMillis()); } }).start(); new Thread(() -> { while (true) { System.out.println(obj.get()); } }).start(); } }

以上测试代码中，一个线程进行赋值操作，另一个线程取值，运行该测试代码可以发现，很容易阻塞在循环等待中。

这是因为写线程写入一个新值，同时将 hasNewValue 置为 true，但是只更新了写线程自己工作线程的缓存值，没有更新主存中的值。而读线程在获取新值是，其工作线程中的 hasNewValue 为 false，会陷入到循环等待中，即使写线程写了新值，读线程也无法获取。因为读线程没有获取都新值，写线程的 hasNewValue 没有被置回 false，所以写线程也会陷入到循环等待中。因此产生了死锁。

使用 volatile 关键字可以解决这个问题，使用 volatile 修饰的变量确保了线程不会将该变量拷贝到自己的工作线程中，所有线程对该变量的操作都是在主存中进行的，所以 volatile 修饰的变量对所有线程可见。

使用 volatile 修饰 hasNewValue，这样在写线程和读线程中都是在主存中操作 hasNewValue 的值，就不会产生死锁。

2. 原子性

volatile 只保证单次读/写操作的原子性，对于多步操作，volatile 不能保证原子性，如下代码所示：

测试类：

class VolatileCounter { private volatile int count = 0; public void inc() { count++; } public void dec() { count--; } public int get() { return count; } }

测试代码：

public class VolatileTest { public static void main(String... args) { while (true) { VolatileCounter counter = new VolatileCounter(); Thread thread1 = new Thread(() -> { for (int i = 0; i < 50; i++) { counter.inc(); } }); Thread thread2 = new Thread(() -> { for (int i = 0; i < 50; i++) { counter.dec(); } }); thread1.start(); thread2.start(); try { thread1.join(); thread2.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("counter = " + counter.get()); } } }

运行结果：

... counter = 0 counter = 0 counter = 0 counter = 0 counter = -21 counter = 0 counter = 0 counter = 0 counter = 0 ...

从运行结果可以看出，绝大部分情况下输出结果为 counter = 0，但也有部分其它结果。由此可知，对于 count++; 和 count--; 这两个操作并不具有原子性。

这是因为 count++ 是一个复合操作，包括三个部分：

1. 读取 count 的值；
2. 对 count 加 1；
3. 将 count 的值写回内存；

volatile 对于这三步操作是无法保证原子性的，所以会出现上述运行结果。

所以，vloatile 并不能解决所有同步的问题

3. 有序性

在 Java 内存模型中，允许编译器和处理器对指令进行重排序，重排序过程不会影响到单线程程序的执行，但是会影响到多线程并发执行的正确性。

volatile 关键字可以禁止指令重新排序，可以保证一定的有序性。

volatile 修饰的变量的有序性有两层含义：

1. 所有在 volatile 修饰的变量写操作之前的写操作，将会对随后该 volatile 修饰的变量读操作之后的语句可见。
2. 禁止 JVM 重排序：volatile 修饰的变量的读写指令不能和其前后的任何指令重排序，其前后的指令可能会被重排序。

3.1 happen-before

happen-before 关系是用来判断是否存在数据竞争、线程是否安全的主要依据，也是指令重排序的依据，保证了多线程下的可见性。

volatile 修饰的变量在读写时会建立 happen-before 关系。

如下面的测试类：

class VolatileOrder { int i = 0; volatile boolean flag = false; public void write() { i = 1; // 步骤 1 flag = true; // 步骤 2 } public String get() { if (flag) { // 步骤 3 System.out.println("i = " + i); // 步骤 4 } } }

上面的代码依据 happen-before 原则（关于 happen-before 原则可自行搜索）会建立如下的关系：

• 根据 happen-before 单线程顺序原则会有：步骤 1 happen-before 步骤 2、步骤 3 happen-before 步骤 4；
• 根据 happen-before 的 volatile 原则会有：步骤 2 happen-before 步骤 3；
• 根据 happen-before 的传递性原则会有：步骤 1 happen-before 步骤 4；

所以 步骤 1 对于 步骤 4 是可见的，即变量 i 在多个线程中具有可见性。

这也解释了 volatile 有序性的第一层含义：所有在 volatile 修饰的变量写操作之前的写操作，将会对随后该 volatile 修饰的变量读操作之后的语句可见。

利用这个特性可以优化变量在线程间的可见性，不需要对每个变量都用 volatile 修饰，只需要用 volatile 修饰一部分变量即可保证其它变量在多线程间也具有可见性。

3.2 禁止 JVM 重排序

对于上述代码，如果变量 flag 没有使用 volatile 修饰，那么步骤 1 和步骤 2 就有可能被 JVM 重排序，就无法得到上述的 happen-before 关系，所以 volatile 修饰的变量禁止 JVM 重排序。

如下代码所示：

class VolatileOrder { int a, b, c; volatile int d; void write() { a = 1; b = 2; c = 3; d = 4; } void read() { int D = d; int A = a; int B = b; int C = c; } }

在 write() 方法中：

a = 1; b = 2; c = 3;

JVM 可能会重排序这三个指令，但是这三个指令一定是排在 d = 4; 这个指令之前。

同样的，在 read() 方法中：

int A = a; int B = b; int C = c;

JVM 可能会重排序这三个指令，但是这三个指令一定是排在 int D = d; 这个指令之后。