前言

众所周知的并发编程三大特性；原子性、可见性、有序性；但是这些特性的起源你知道吗？

可见性：正是由于CPU存在缓存，导致了变量修改的不可见性；

原子性：线程切换是基于CPU指令而不是高级语言中的一行代码，线程切换可以发生在任意一条CPU指令执行之前，完成之后，因此只能保证CPU指令的原子性；

有序性：最诡异的特性，一行代码被拆分成多个CPU指令，但是为了保持高性能，编译器对其做了排序，可能导致顺序改变。

好了，以上的三大特性已经了解了，但是如何解决这些问题呢？

正题来了，Java内存模型提供了一种规则：happens-before；

happens-before：前面一个操作的结果对后续操作是可见的。

happens-before是Java内存模型中最晦涩的内容，其中涉及到的规则有如下六项，下文将会逐一介绍。

1. 程序的顺序性规则

这条规则指在一个线程中，按照程序顺序，程序前面对某一个变量的修改一定对后续操作可见的。

如下一段代码：

@Test
public void test(){
  int a=10;
  int b=100;
  a=11;
  b+=10;
}

上述代码中的a=11一定是对b+=10这行代码可见的。

2. volatile 变量规则

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

简单的理解：一个线程修改了volatile变量，则对另外一个线程读取volatile的变量是可见的。

3. 传递性

很好理解的一个特性，比如A Happens-Before B，且 B Happens-Before C，那么 A Happens-Before C。

举个栗子：有如下代码：

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

两个线程分别执行writer()和reader()方法，如下图：

                       传递性示例图

从上图可以知道以下内容：

1. x=42对于写变量v=true是可见的，符合规则一。
2. 写变量v=true对于读变量v==true是可见的，这是规则二的内容。

结合这个传递性，则x=42对于读变量v==true是可见的。则如果线程B读到了v==true，那么线程A设置的x=42对于线程B来说是可见的。

这个传递性的意义重大，1.5版本的并发工具包就是靠volatile搞定可见性的。

4. 管程中锁的规则

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

管程是一种通用的同步原语，在 Java 中指的就是 synchronized，synchronized是 Java 里对管程的实现。

管程中的锁是隐式实现的，在进入同步块之前加锁，在代码块执行完之前自动释放锁，一切都是无感知的，如下代码：

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

规则4是什么意思呢？假设A，B两个线程，A线程进入代码块加锁，此时的x<20，则修改x=20，执行完成后自动释放锁（解锁），此时B线程进入代码块，自动加锁，则A线程修改的x=20此时对于B线程是可见的。如下图：

                                        管程中锁示例图

5. 线程 start() 规则

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

简单的理解则是如果线程A执行了线程B的start()方法，则线程A在start()之前的操作结果对于线程B都是可见的，如下代码：

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

上述代码中，主线程在start()之前对于共享变量a的修改对于B线程是可见的。

6. 线程 join() 规则

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

换句话说，如果线程A调用了线程B的join()方法，那么当线程B执行完成后，其中的所有操作对于线程A都是可见的，如下代码：

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

从上述代码可以知道，线程B执行完成之后，线程B对于共享变量a的修改对于主线程来说是可见的。

总结

本文着重介绍了Happens-Before的六大规则，其在Java内存模型中的作用不可小觑，你看懂了吗？