Java 之 volatile 详解
一、概念
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++ 是一个复合操作，包括三个部分：
-
读取 count 的值；
-
对 count 加 1；
-
将 count 的值写回内存；
volatile 对于这三步操作是无法保证原子性的，所以会出现上述运行结果。
所以，vloatile 并不能解决所有同步的问题
3. 有序性
在 Java 内存模型中，允许编译器和处理器对指令进行重排序，重排序过程不会影响到单线程程序的执行，但是会影响到多线程并发执行的正确性。
volatile 关键字可以禁止指令重新排序，可以保证一定的有序性。
volatile 修饰的变量的有序性有两层含义：
-
所有在 volatile 修饰的变量写操作之前的写操作，将会对随后该 volatile 修饰的变量读操作之后的语句可见。
-
禁止 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; 这个指令之后。
