使用 volatile 关键字保证变量可见性和禁止指令重排序

volatile 概述

volatile 是 Java 提供的一种轻量级的同步机制。相比于传统的 synchronize，虽然 volatile 能实现的同步性要差一些，但开销更低，因为它不会引起频繁的线程上下文切换和调度。

为了更好的理解 volatile 的作用，首先要了解一下 Java 内存模型与并发编程三要素

Java 内存模型

Java 虚拟机规范中定义了 Java 内存模型（Java Memory Model，JMM），用于屏蔽各种硬件和操作系统的内存访问差异，以实现让 Java 程序在各种平台下都能达到一致的并发效果。

JMM 规定了 Java 虚拟机与计算机内存如何协同工作：一个线程如何和何时可以看到由其他线程修改过后的共享变量的值，以及在必须时如何同步的访问共享变量。注意这里的变量是指实例字段，静态字段，构成数组对象的元素，不包括局部变量和方法参数（因为这是线程私有的），可以简单理解为主内存是 Java 虚拟机内存区域中的堆，局部变量和方法参数是在虚拟机栈中定义的。如果堆中的变量在多线程中都被使用，就涉及到了堆和不同虚拟机栈中变量的值的一致性问题了。

Java 内存模型中涉及到的概念有：

主内存

Java 虚拟机规定所有的变量都必须在主内存中产生，该内存是线程公有的，为了方便理解，可以认为是堆区。
工作内存

Java 虚拟机中每个线程都有自己的工作内存，该内存是线程私有的，为了方便理解，可以认为是虚拟机栈。

Java 虚拟机规定，线程对主内存变量的修改必须在线程的工作内存中进行，不能直接读写主内存中的变量。不同的线程之间也不能相互访问对方的工作内存。如果线程之间需要传递变量的值，必须通过主内存来作为中介进行传递。

并发编程三要素

在并发编程中，以下三要素是我们经常需要考虑的：

原子性

原子是世界上最小的单位，具有不可分割性。同理，将一个操作或多个操作视为一个整体，它们是不可再分的，并且要么全部成功，要么全部失败，那么这个操作就具有原子性。
```
int a = 10; //1

a++; //2

int b = a; //3

a = a + 1; //4
```
上面这四个语句中只有第 1 个语句是原子操作，将 10 赋值给线程工作内存的变量 a，而语句2（a++），实际上包含了三个操作：
1. 读取变量 a 的值
2. 对 a 进行加一的操作
3. 将计算后的值再赋值给变量 a，而这三个操作无法构成原子操作
对语句 3，4 的分析同理可得这两条语句不具备原子性。
可见性

指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。举个简单的例子：
```
// 线程 1 执行的代码

int i = 0;

i = 10;

//线程 2 执行的代码

j = i;
```
之前在 Java 内存模型已经讲过，线程 1 执行 i = 10 时，会先把 i 的初始值加载到自己的工作内存，然后赋值为 10，却没有立即写入到主存当中。此时线程 2 执行 j = i，它会先去主存读取 i 的值并加载到自己的工作内存中，注意此时内存当中 i 的值还是 0，那么就会使得 j 的值为 0，而不是 10。

这就是可见性问题，线程 1 对变量 i 修改了之后，线程 2 没有立即看到线程 1 修改的值。
有序性

程序的执行顺序按照代码的先后顺序执行。有序性从不同的角度来看是不同的，单纯从单线程的角度来看，所有操作都是有序的，但到了多线程就不一样了。可以这么说：如果在本线程内部观察，所有操作都是有序的；如果在一个线程中观察另一个线程，所有的操作都是无序的。

volatile 保证变量可见性

假如有 A、B 两个线程，主内存有变量 i = 0，A 线程将主内存中的 i 拷贝一份到自己的工作内存，并修改为 i = 1，但并没有立即写回到主内存，什么时候写回主存是不确定的。此时 B 线程也将主内存中的 i 拷贝一份到自己的工作内存，而主内存中的 i 还是 0，并不是预想中的 1，这就可能导致一些问题。

volatile 的一个重要作用就是实现了变量可见性。当一个共享变量被 volatile 修饰，它会保证修改的值会立即更新到主存，当其他线程需要读取时，它会去内存中读取新值。

volatile 不保证原子性

假如有 A、B 两个线程，同时对初始值为 0 的变量 i 做加 1 操作，我们希望最终的结果是 i = 2，但有可能并非如此，假设：

线程 A 将共享内存 i = 0 拷贝到自己的工作内存，此时 A 的本地内存中 i = 1，但共享内存的 i 还是 0
线程 B 将共享内存 i = 0 拷贝到自己的工作内存，此时 B 的本地内存中 i = 1，但共享内存的 i 还是 0
线程 A 完成加 1 操作，此时 A 的本地内存中 i = 1，但共享内存的 i 还是 0，线程 A 将 i = 1 写回到内存
线程 B 完成加 1 操作，此时 B 的本地内存中 i = 1，共享内存的 i 已经是 1，线程 B 将 i = 1 写回到内存
最终共享内存中 i = 1，并不是我们预期的 i = 2

出现上述问题的原因是 i++ 并不是一个原子性的操作，Java 内存模型只保证了基本读取和赋值是原子性操作。不同线程之间的操作交互执行，可能会出现漏洞。所以使用 volatile 必须具备以下两个条件：

对变量的写操作不依赖于当前值
该变量没有包含在具有其他变量的不变式中

上述两个条件其实就是要保证操作是原子性的。如果希望实现更大范围操作的原子性，可以通过 synchronized 和 Lock 来实现。synchronized 和 Lock 能保证任一时刻只有一个线程执行该代码块，自然就不存在原子性问题。

volatile 禁止指令重排序

所谓指令重排序，是指计算机在执行程序时，为了提高性能，编译器和处理器常常会对指令进行重排。指令重排必须保证最终执行结果和代码顺序执行结果一致。

public void mySort() {

	int x = 11;	// 1

	int y = 12; // 2

	x = x + 5;  // 3

	y = x * x;  // 4

}

正常的执行顺序是 1、2、3、4，如果发生指令重排，就有可能会是 2、1、3、4，或者是 1、3、2、4 等等，但不会出现 4、3、2、1 这样的情况，因为处理器在进行重排时，必须考虑到指令之间的数据依赖性。

在单线程下指令重排是没有问题的，但如果是多线程就不一定了，假设主存中有 a，b，x，y 四个变量（保证了可见性），初始值都是 0，有 A、B 两个线程，它们各自顺序执行时操作如下：

线程 A
- x = a
- b = 1
线程 B
- y = b
- a = 2

无论两个线程之间的操作如何交错，最终结果都是 x = 0，y = 0（不考虑线程 A 走完再到线程 B 的情况，因为这样就和单线程没有差异了）。可如果发生了指令重排，此时它们各自的操作执行顺序可能变为：

线程 A
- b = 1
- x = a
线程 B
- a = 2
- y = b

这样造成的结果就是 x = 2，y = 1，和上面的不一致了。因此为了防止这种情况，volatile 规定禁止指令重排，从而保证数据的一致性。