用 volatile 修饰的变量能够保证其对所有线程的可见性，要理解这一点，我们首先需要了解 Java 的内存模型。
1. Java 内存模型
Java 内存模型分为主内存和工作内存。
主内存是对所有线程所共享的，此外每个线程有自己的工作内存，工作内存不共享。
线程在工作时，从主内存中拷贝所需变量到自己的工作内存中。
线程对变量的所有操作，都必须在工作内存中进行，不能直接操作主存中的变量，也不能直接访问其他线程的工作内存。
线程间变量值的传递需要通过主内存进行，何时将工作内存中的变量同步到主内存，由 JVM 控制。
基于此种内存模型，在多线程中会产生脏读，即读到非最新的数据。
譬如，有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 和 系统内存间的交互：
对于多核心处理器，每个处理器都有自己的高速缓存，用于缓存计算中间结果。当不同核心上执行的运算任务涉及到同一块内存区域时，就有可能出现缓存不一致的问题。
我们看看 Java 虚拟机是如何解决这个问题的，当对用 volatile 修饰的变量进行了写操作时，JVM 会向 CPU 发送一条 Lock 前缀的指令，该指令将做以下2件事情：
- 将 CPU 高速缓存中的数据写回到系统内存；
- 如果其他 CPU 核心缓存了该数据，将其置为失效。
其中 操作2 是通过缓存一致性协议实现的： 每个处理器通过嗅探在总线上传播的数据，检查自己缓存中的数据是否过期，当处理器发现高速缓存中的数据对应的内存地址被修改，会将该缓存数据置为失效，当处理器下次访问该内存地址数据时，将强制重新从系统内存中读取。
4. volatile 的使用说明
我们已经解释了 volatile 的实现原理和作用，那么它能避免文章开头提到的脏读问题吗？答案是并不能，原因是 volatile 不能实现原子性操作。
原子性操作是不可再拆分的操作，要么执行，要么不执行。
原子操作不会被线程调度机制打断，不需要 synchronized。
i++ 虽然仅包含一行语句，但实际上它进行了 3 项操作：
- 从内存中读取 i 的至；
- 对 i 进行 +1 操作
- 将 i 的新值写入到内存中。
即便 volatile 能够保证 线程A 进行了 i+1 操作后，i 的新值将被立即更新到主存。但在 i 写入到主存前，可能线程B已经读取了 i 值，此时 i 仍为 0。在线程A 将 i 的新值写到主存后，线程B 的工作内存中 i 的缓存将失效，但此时线程B已无需再读取 i 值。所以两次 +1 操作后最终 i=1。
执行以下代码能证明上文这一点：
public class VolatileDemo {
private volatile int i;
public void inc() {
i++;
}
public int getI() {
return i;
}
public static void main(String[] args) {
final VolatileDemo test = new VolatileDemo();
for (int i = 0; i < 10; i++) {
new Thread(() -> {
for (int j = 0; j < 1000; j++) {
test.inc();
}
}).start();
}
while (Thread.activeCount() > 1) {
Thread.yield();
}
System.out.println(test.getI());
}
}
执行多次，发现控制台打印的 i 值总是小于预期结果 10 * 1000 = 10000.
若要达到预期效果，则必须让 i++ 变为原子操作，这就需要通过 synchronized 实现，将 inc() 函数改为：
public synchronized void inc() {
i++;
}
则每次执行结果都为 10000.
由于 volatile 无法保证操作的原子性，在多线程场景下使用 volatile 需要保证以下2点：
- 对变量的写操作不依赖于当前值；
- 该变量不会与其他变量被一起纳入到不变性条件中（譬如下界 <= 上界）。
下面举几个应用场景：
- 用作状态标记
volatile boolean shutdownFlag;
public void shutdown() {
shutdownFlag = true;
}
public void doWork() {
while (!shutdownFlag) {
doSomething();
}
}
在 shutdown() 方法中，shutdownFlag = true 的赋值操作，与 shutdownFlag的当前值无关。而上文中的 i++ 操作，i 的新值依赖于当前值。
- 双重检查
class Singleton {
private volatile static Singleton instance = null;
private Singleton() {
}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null)
instance = new Singleton();
}
}
return instance;
}
}
在1个线程执行完语句 instance = new Singleton(); 后，等待在同步锁外的其他线程在判断 if (instance == null) 时，会重新从主存中读取 instance 变量，从而发现其已构造完毕，方法实现了单例模式。
