Volatile实现原理

 读写volatile变量就像是访问一个同步块一样，是原子的且是可见的，总是能访问到最新的值。

原子性

 读写volatile变量是原子操作，但读写变量不就是一条指令的事吗（mov、ldr），难道这还可分？没错绝大多数变量读写都是原子的，除了在32位JVM下对long、double的读写，就不是原子的。这是因为在32位下，总线宽度就只有32bit，对64位数据的读写需要分两次进行，依次读写高低32位。但是读写volatile变量由于使用了LOCK前缀指令，锁住了内存，所以即使是64位的数据也是原子的。

 读写volatile变量是原子的，包括64位的long和double

实现原子性

 实现64位的原子性，需要在读写volatile变量时，使用Lock前缀指令，其作用有：

1. 锁住该内存地址，直到读完/写完，保证64位变量读写原子性。少量处理器是使用锁总线实现的，相比锁内存，其开销更大，锁总线期间，所有处理器都不能操作主存外存。
2. 将写缓存刷新到主存，保证可见性
3. 禁止该指令与前面和后面的读写指令重排序，保证happens-before关系

可见性

happens-before中定义了：写volatile变量，happens-before后面任意一个读这个volatile变量的操作

 这意味着volatile变量在多线程间具有可见性，从源码到Runtime发生的重排序指出重排序破坏了可见性。为实现volatile的可见性，读写volatile时则需要禁止重排序，那么需要禁止编译器重排序和处理器重排序

happens-before关系

happens-before规则

1. 程序顺序规则：在一个线程中，前面的操作happens-before后面的操作
2. volatile写-读规则：写volatile变量，happens-before后面任意一个读这个volatile变量的操作
3. 传递性规则：A happens-before B，B happens-before C，则A happens-before C

 从这段代码看看happens-before关系，线程A先执行store()，线程B后执行load()

int value = 0;
volatile boolean finish = false;

void store(){
    value = 1;      //A
    read(value);    //B
    finish = true;  //C
    value = 2;      //D
    read(value);    //E
}

void load(){
    value = 3;      //F
    read(value);    //G
    while(!finish); //H
    assert value == 1;  //I
    value = 4;      //J
}

 ①~⑧是程序顺序规则，⑨是volatile写-读规则，浅色的是传递性规则，后面详细解释这些关系。

从happends-before规则分析可见性

 ①~⑧是根据程序顺序规则得出的，程序顺序规则前提是仅考虑本线程的可见性，那么就不需要考虑多个处理器引发的缓存不一致问题，不需要考虑内存系统重排序，所以不需要用到内存屏障。这样就很简单了，只要保证其在单线程内运行结果不变即可，只要保证编译器、处理器不重排数据依赖的指令。

 ⑨是根据volatile域写-读规则得出的得出：C happens-before H。也就是线程A写volatile happens-before 线程B读volatile。

 再根据传递性规则得出：ABC happens-before H 。也就是线程A写volatile及其之前的操作 happens-before 线程B读volatile。

 再根据传递性规则得出：ABC happens-before HIJ 。最终得出线程A写volatile及其之前的操作 happens-before 线程B读volatile及其后续操作

 这样来看，写volatile时，需要马上将本地内存刷新到主存中去。读volatile时，需要将本地内存中共享变量设为无效状态，重新从主存中读。

编译器层面实现可见性

可以看到：

• 写volatile变量时，无论前一个操作是什么，都不能重排序（①~④happens-before）
• 读volatile变量时，无论后一个操作是什么，都不能重排序（⑤~⑧happens-before）
• 当先写volatile变量，后读volatile变量时，不能重排序（⑨happens-before）

处理器层面实现可见性

根据前面的出来的可见性：线程A写volatile及其之前的操作 happens-before 线程B读volatile及其后续操作。

 可以看到这个可见性是在多线程间的，所以要避免内存系统重排序，需要使用JMM提供的内存屏障


 先给可见性拆分，方便从最简单的开始实现：

1. 线程A写volatile happens-before 线程B读volatile
2. 线程A写volatile及其之前的操作 happens-before 线程B读volatile
3. 线程A写volatile及其之前的操作 happens-before 线程B读volatile及其后续操作

 实现可见性：

1. 对第一级可见性，可以在写volatile之后加StoreLoad Barrier，也可以在读volatile之前加StoreLoad Barrier。选择哪种？在实际开发中，常用的模式是一个写线程，多个读线程，典型的有生产者消费者模式，所以在写volatile后加StoreLoad Barrier，会大大减少执行屏障的次数，比后者的性能要好。
2. 对第二级可见性，在写volatile之前加上StoreStore Barrier，可以保证写volatile之前，其之前的所有操作结果已经可见。不用LoadStore Barrier的原因是：读操作并不会改变操作结果。
3. 对第三级可见性，实际上是保证读volatile后续操作会不会和读volatile重排序。那么就在读volatile后面加LoadLoad Barrier，这样保证读volatile在其后续读操作之前执行，这样的话 线程A 对 读volatile的后续读操作也可见。同理为了使线程A 对 读volatile后续写操作可见，在读volatile后加上LoadStore Barrier。

 综上所述：

1. 写volatile之前，StoreStore Barrier
2. 写volatile之后，StoreLoad Barrier
3. 读volatile之后，LoadLoad Barrier 和 LoadStore Barrier

 在刚才的例子上添加内存屏障，实现happens-before关系。

int value = 0;
volatile boolean finish = false;

void store(){
    value = 1;      //A
    read(value);    //B
    storeStoreBarrier();
    finish = true;  //C
    storeLoadBarrier();
    value = 2;      //D
    read(value);    //E
}

void load(){
    value = 3;      //F
    read(value);    //G
    while(!finish); //H
    loadLoadBarrier();
    loadStoreBarrier();
    assert value == 1;  //I
    value = 4;      //J
}