volatile底层原理
前言
volatile是轻量级的synchronized，是Java内部的一个轻量级锁
volatile具有三大特性：
可见性：在多线程中保证了共享变量的“可见性”。（当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。）原子性：对任意单个volatile变量的读/写具有原子性，但类似于volatile++这种复合操作不具有原子性。禁止指令重排：volatile变量读/写操作会加“内存屏障”，防止指令重排。
可见性
volatile可以保证可见性，那它是如何保证的呢？
在此之前，先了解一下Java内存模型（JMM），JMM决定一个线程对共享变量的写入何时对另一个线程可见。
多线程中，内存主要分为两种，一个是系统内存（主内存，线程之间的共享变量存储在主内存（Main Memory）中），一个是线程内部的本地内存（每个线程都有一个私有的本地内存（Local Memory），本地内存中存储了该线程以读/写共享变量的副本）。
如图所示（Java内存模型的抽象结构）：
线程A与线程B之间要通信的话，必须要经历下面2个步骤。
- 线程A把本地内存A中更新过的共享变量刷新到主内存中去。
- 线程B到主内存中去读取线程A之前已更新过的共享变量。
如图：
通信过程必须要经过主内存。JMM通过控制主内存与每个线程的本地内存之间的交互，来为Java程序员提供内存可见性保证。
OK！了解完Java内存模型，我们来看下volatile到底是如何保证可见性的！
与volatile实现原理相关的CPU术语：
通过工具获取JIT编译器生成的汇编指令来查看对volatile进行写操作时，CPU会做什么事情。
Java代码：
// 变量由volatile修饰
private volatile Singleton instance = new Singleton();
转变成汇编代码，如下：
0x01a3de1d: movb $0×0,0×1104800(%esi);
0x01a3de24: lock addl $0×0,(%esp);
由volatile变量修饰的共享变量进行写操作的时候会多出第二行汇编代码。
Lock前缀的汇编指令在多核处理器下会引发了两件事情：
将当前处理器缓存行的数据写回到系统内存。（相当于将线程里的本地内存数据刷回主内存）这个写回内存的操作会使在其他CPU里缓存了该内存地址的数据无效（使其他线程中本地缓存中该内存地址的数据无效）。
为了提高处理速度，处理器不直接和内存进行通信，而是先将系统内存的数据读到内部缓存（L1，L2或其他）后再进行操作，但操作完不知道何时会写到内存。
对声明了volatile的变量进行写操作，JVM就会向处理器发送一条Lock前缀的指令，将这个变量所在缓存行的数据写回到系统内存。
就算将该线程处理过后的数据写回到内存，如果其他处理器缓存的值还是旧的，再执行计算操作就会有问题。多处理器下，为了保证各个处理器的缓存是一致的，就会实现缓存一致性协议MESI。
每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状态， 当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据读到处理器缓存里，就能保证每次处理的数据都是最后一次被写入的都是最新的。
volatile的两条实现原则：
- Lock前缀指令会引起处理器缓存回写到内存。Lock前缀指令导致在执行指令期间，声言处理器的LOCK#信号。在多处理器环境中，
LOCK#信号确保在声言该信号期间，处理器可以独占任何共享内存。LOCK＃信号一般不锁总线，而是锁缓存，锁总线开销的比较大。如果访问的内存区域已经缓存在处理器内部，则不会声言LOCK#信号。相反，它会锁定这块内存区域的缓存并回写到内存，并用缓存一致性机制来确保修改的原子性，此操作被称为“缓存锁定”，缓存一致性机制会阻止同时修改两个以上处理器缓存的内存区域数据。 - 一个处理器的缓存回写到内存会导致其他处理器的缓存无效。处理器使用嗅探技术保证它的内部缓存、系统内存和其他处理器的缓存的数据在总线上保持一致。通过嗅探一个处理器来检测其他处理器打算写内存地址，而这个地址当前处于共享状态，那么正在嗅探的处理器将使它的缓存行无效，在下次访问相同内存地址时，强制执行缓存行填充（重新读取系统内存数据）。
总而言之，volatile变量被操作时，会第一时间把操作后的数据从线程本地内存刷会主内存，并使得其他线程该地址数据无效，其他线程下次操作该数据时，发现该数据无效会重新读取主内存数据，因而保证volatile变量在多线程中的可见性。
小demo：
public class VolatileDemo {
private volatile int num = 0;
public void startThread() {
Runnable runnable = () -> {
/*
num变量不加volatile修饰，子线程永远不会停止，主线程修改num值，子线程无法感知num发生变化；
一旦num加上volatile修饰，只要其他线程修改num值，子线程立马就能感知到，程序直接结束
*/
while (num == 0) {
}
};
// 开启一个线程
new Thread(runnable).start();
}
public void updateNum() {
num = 1;
}
public static void main(String[] args) {
VolatileDemo demo = new VolatileDemo();
demo.startThread();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
// 等待一秒，主线程修改num值
demo.updateNum();
}
}
原子性
对volatile变量的单个读/写，看成是使用同一个锁对这些单个读/写操作做了同步。
class VolatileFeaturesDemo {
volatile long vl = 0L;
// 单个volatile变量的写
public void set(long l) {
vl = l;
}
// 复合（多个）volatile变量的读/写
public void getAndIncrement() {
vl++;
}
// 单个volatile变量的读
public long get() {
return vl;
}
}
上面程序在语义上和下面程序等价。
class VolatileFeaturesExample {
long vl = 0L;
// 对单个的普通变量的写用同一个锁同步
public synchronized void set(long l) {
vl = l;
}
public void getAndIncrement() { // 普通方法调用
long temp = get(); // 调用已同步的读方法
temp += 1L; // 普通写操作
set(temp); // 调用已同步的写方法
}
// 对单个的普通变量的读用同一个锁同步
public synchronized long get() {
return vl;
}
}
如上例子，一个volatile变量的单个读/写操作，与一个普通变量的读/写操作都是使用同一个锁来同步，它们之间的执行效果相同。
锁的语义决定了临界区代码的执行具有原子性。volatile变量，对该变量的读/写就具有原子性。如果是多个volatile操作或类似于volatile++这种复合操作，这些操作整体上不具有原子性。
public class VolatileDemo1 {
private static volatile int num = 0;
public static void increase() {
num++;
}
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
// 创建一百个线程，每个线程数字+1000
new Thread(() -> {
for (int j = 0; j < 1000; j++) {
increase();
}
}).start();
}
// 确保10个子线程执行完毕
while (Thread.activeCount() > 2) { // main gc
Thread.yield();
}
// 期望10000，实际上到不了
System.out.println(num);
}
}
加Lock锁或者是synchronized可以保证increase方法的原子性，可以得到预期结果，这种情况还可以使用原子类（CAS）
重排序
重排序是指编译器和处理器为了优化程序性能而对指令序列进行重新排序的一种手段。
重排序分3种类型。
- 编译器优化的重排序。编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。
- 指令级并行的重排序。现代处理器采用了指令级并行技术（Instruction-Level Parallelism，ILP）来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。
- 内存系统的重排序。由于处理器使用缓存和读/写缓冲区，这使得加载和存储操作看上去可能是在乱序执行。
从Java源代码到最终实际执行的指令序列，会分别经历下面3种重排序，如图：
1属于编译器重排序，2和3属于处理器重排序。这些重排序可能会导致多线程程序出现内存可见性问题。
对于编译器，JMM的编译器重排序规则会禁止特定类型的编译器重排序（不是所有的编译器重排序都要禁止）。
对于处理器重排序，JMM的处理器重排序规则会要求Java编译器在生成指令序列时，插入特定类型的
内存屏障（Memory Barriers，Intel称之为Memory Fence）指令，通过内存屏障指令来禁止特定类型的处理器重排序。
JMM把内存屏障指令分为4类：
如果两个操作访问同一个变量，且这两个操作中有一个为写操作，此时这两个操作之间就存在数据依赖性。
数据依赖分为下列3种类型：
上面3种情况，只要重排序两个操作的执行顺序，程序的执行结果就会被改变。
编译器和处理器在重排序时，会遵守数据依赖性，编译器和处理器不会改变存在数据依赖关系的两个操作的执行顺序。
单线程情况
单线程情况下，具有数据依赖性的操作，重排序会影响结果，因此不能重排序；如果操作之间不存在数据依赖关系（重排序不影响最后的结果），这些操作就可能被编译器和处理器重排序。
多线程情况
多线程情况下，单一线程时，没有数据依赖关系操作的重排序可能会影响最后多线程的结果，导致多线程得不到预期结果。
如下例子：
class ReorderExample {
int a = 0;
boolean flag = false;
public void writer() {
a = 1; // 1
flag = true; // 2
}
public void reader() {
if (flag) { // 3
int i = a * a; // 4
}
}
}
假设有两个线程A和B，A首先执行writer()方法，随后B线程接着执行reader()方法。
由于操作1和操作2没有数据依赖关系，编译器和处理器可以对这两个操作重排序；同样，操作3和操作4没有数据依赖关系，编译器和处理器也可以对这两个操作重排序。
会有下面这种情况出现：
操作1和操作2做了重排序。程序执行时，线程A首先写标记变量flag，随后线程B读这个变量。由于条件判断为真，线程B将读取变量a。此时，变量a还没有被线程A写入，在这里多线程程序的语义被重排序破坏了！
为了实现volatile内存语义，JMM会分别限制这两种类型的重排序类型。
重排序分为编译器重排序和处理器重排序。为了实现volatile内存语义，JMM会分别限制这两种类型的重排序类型。
volatile重排序规则表
由表可知：
- 当第二个操作是volatile写时，不管第一个操作是什么，都不能重排序。这个规则确保volatile写之前的操作不会被编译器重排序到volatile写之后。
- 当第一个操作是volatile读时，不管第二个操作是什么，都不能重排序。这个规则确保volatile读之后的操作不会被编译器重排序到volatile读之前。
- 当第一个操作是volatile写，第二个操作是volatile读时，不能重排序。
为了实现volatile的内存语义，编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。
基于保守策略的JMM内存屏障插入策略。
- 在每个volatile写操作的前面插入一个StoreStore屏障。
- 在每个volatile写操作的后面插入一个StoreLoad屏障。
- 在每个volatile读操作的后面插入一个LoadLoad屏障。
- 在每个volatile读操作的后面插入一个LoadStore屏障。
插入内存屏障，保证指令不会被重排，保证语意的正确性。
volatile写和volatile读的内存屏障插入策略非常保守。在实际执行时，只要不改变volatile写-读的内存语义，编译器可以根据具体情况省略不必要的屏障。
class VolatileBarrierExample {
int a;
volatile int v1 = 1;
volatile int v2 = 2;
void readAndWrite() {
int i = v1; // 第一个volatile读
int j = v2; // 第二个volatile读
a = i + j; // 普通写
v1 = i + 1; // 第一个volatile写
v2 = j * 2; // 第二个volatile写
}
}
针对readAndWrite()方法，编译器在生成字节码时可以做如下的优化。
