【多线程】Volatile和Happens-Before原则

Happens-Before原则

Happens-Before原则：前面一个操作的结果对后续操作是可见的。
Happens-Before原则约束了编译器的优化行为，虽允许编译器优化，但是要求编译器优化后一定遵守Happens-Before原则。即使编译器进行指令重排序的优化，如果结果和重排序前一致，也是允许的。

Happens-Before原则一共六条，都是关于可见性的。

1.程序的顺序性规则

这条规则是指在一个线程中，按照程序顺序，前面的操作Happens-Before于后续的任意操作。

按照程序的顺序，第6行代码“x=42;”Happens-Before 于第7行代码“v=true;”，这就是规则1的内容，比较符合单线程里面的思维：程序前面对某个变量的修改一定是对后续操作可见的。

class VolatileExample {
  int x = 0;
  volatile boolean v = false;
  public void writer() {
    x = 42;
    v = true;
  }
  public void reader() {
    if (v == true) {
      // 这里 x 会是多少呢？
    }
  }
}

2.Volatile变量规则

这条规则是指对一个volatile 变量的写操作，Happens-Before于后续对这个volatile变量的读操作。

3.传递性

这条规则是指如果 A Happens-Before B，且 B Happens-Before C ，那么A Happens-Before C。

1. “x=42” Happens-Before 写变量 “v=true” ，这是规则 1 的内容
2. 写变量“v=true” Happens-Before 读变量 “v=true”，这是规则 2 的内容

根据传递性规则，可以得到：“x=42;” Happens-Before 读变量“v=true;” ，这意味着如果线程B读到了“v=true”，那么线程A设置的“x=42;”对线程B是可见的。即线程B能看到“x=42;”。

4.锁定规则

这条规则是指对一个锁的解锁Happens-Before 于后续对这个锁的加锁。

要理解这个规则，就首先要了解管程。管程是一种通用的同步原语，在java中指的就是synchronized，synchronized是java里对管程的实现。

管程中的锁在Java里是隐式实现的，例如下面的代码，在进入同步块之前，会自动加锁，而在代码块执行完会自动释放锁，加锁以及释放锁都是编译器帮我们实现的。

synchronized (this) { // 此处自动加锁
  // x 是共享变量, 初始值 =10
  if (this.x < 12) {
    this.x = 12; 
  }  
} // 此处自动解锁

所以结合规则 4——管程中锁的规则，可以这样理解：假设 x 的初始值是 10，线程 A 执行完代码块后 x 的值会变成 12（执行完自动释放锁），线程 B 进入代码块时，能够看到线程 A 对 x 的写操作，也就是线程 B 能够看到 x=12。

5.线程启动规则（start）

这条是关于线程启动的。它是指主线程A启动子线程B后，子线程B能够看到主线程在启动子线程B前的操作。

换句话说就是，如果线程A调用线程B的start（）方法（即在线程A中启动线程B），那么该start（）操作Happens-Before于线程B中的任意操作。

Thread B = new Thread(()->{
  // 主线程调用 B.start() 之前
  // 所有对共享变量的修改，此处皆可见
  // 此例中，var==77
});
// 此处对共享变量 var 修改
var = 77;
// 主线程启动子线程
B.start();

6.线程终结原则（join）

这条是关于线程等待的。它是指主线程A等待子线程B完成（主线程A通过调用子线程B的join（）方法实现），当子线程B完成后（主线程A中join（）方法返回），主线程能够看到子线程的操作。“看到”指的是对共享变量的操作。

换句话说就是，如果在线程 A 中，调用线程 B 的 join() 并成功返回，那么线程 B 中的任意操作 Happens-Before 于该 join() 操作的返回。

Thread B = new Thread(()->{
  // 此处对共享变量 var 修改
  var = 66;
});
// 例如此处对共享变量修改，
// 则这个修改结果对线程 B 可见
// 主线程启动子线程
B.start();
B.join()
// 子线程所有对共享变量的修改
// 在主线程调用 B.join() 之后皆可见
// 此例中，var==66

Volatile

java1.5之后，通过happen-before原则增强了volatile关键词。volatile关键词是轻量的实现线程安全的方法，保证了volatile变量的有序性和可见性。

1.volatile保证了变量在线程间的可见性（ MESI 协议）

当写 volatile 变量时，JMM 会立即把该线程对应的本地内存中的共享变量值刷新到主内存。

当读 volatile 变量时，JMM 会把该线程对应的本地内存置为无效。线程接下来将从主内存中读取共享变量。

volatile 保证内存可见性，其实是用到了 CPU 保证缓存一致性的 MESI 协议。当某线程对 volatile 变量的修改会立即回写到主存中，并且导致其他线程的缓存失效，强制其他线程再使用变量时，需要从主存中读取。

2.volatile保证了有序性（内存屏障）

volatile变量在读写操作前后添加内存屏障，禁止了指令的重排序，保证了有序性。

内存屏障有LoadLoad屏障，StoreStore屏障，LoadStore屏障，StoreLoad屏障。比如loadload屏障，加在Load1; Load2两个原子操作之间 ，保证在Load2及后续的读操作读取之前，Load1已经读取。其他同理。

在每个volatile写入之前，插入一个StoreStore，写入之后，插入一个StoreLoad

在每个volatile读取之前，插入LoadLoad，之后插入LoadStore。

禁止重排序规则如下图。

3.volatile无法保证原子性，只能保证自身读写为原子操作

对volatile变量的读写 相当与给读写方法加了synchronized关键词，但volatile更轻量级。