（每日一题）什么是HappensBefore规则？有什么用？

今日问题

---

有如下代码：

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

假设线程 A 执行 writer() 方法，按照 volatile 语义，会把变量 “v=true” 写入内存；假设线程 B 执行 reader() 方法，同样按照 volatile 语义，线程 B 会从内存中读取变量 v，如果线程 B 看到 “v == true” 时，那么线程 B 看到的变量 x 是多少呢？

直觉上看，应该是 42，那实际应该是多少呢？这个要看 Java 的版本，如果在低于 1.5 版 本上运行，x 可能是 42，也有可能是 0；如果在 1.5 以上的版本上运行，x 就是等于 42。

分析一下，为什么 1.5 以前的版本会出现 x = 0 的情况呢？我相信你一定想到了，变量 x 可能被 CPU 缓存而导致可见性问题。这个问题在 1.5 版本已经被圆满解决了。Java 内存 模型在 1.5 版本对 volatile 语义进行了增强。怎么增强的呢？答案是一项 HappensBefore 规则。

HappensBefore 规则

---

HappensBefore真正表达的意思是：前面一个操作的结果对后续操作是可见的。Happens-Before 规则应该是 Java 内存模型里面最晦涩的内容了，和程序员相关的规则 一共有如下六项，都是关于可见性的。

恰好前面示例代码涉及到这六项规则中的前三项，为便于你理解，我也会分析上面的示例 代码，来看看规则 1、2 和 3 到底该如何理解。至于其他三项，我也会结合其他例子作以说明。

1、程序的顺序性规则 

这条规则是指在一个线程中，按照程序顺序，前面的操作 Happens-Before 与后续的任意 操作。这还是比较容易理解的，比如刚才那段示例代码，按照程序的顺序，第 6 行代码 “x = 42;” Happens-Before 与第 7 行代码 “v = true;”，这就是规则 1 的内容，也比 较符合单线程里面的思维：程序前面对某个变量的修改一定是对后续操作可见的。

2、volatile 变量规则 

这条规则是指对一个 volatile 变量的写操作， Happens-Before 于后续对这个 volatile 变量的读操作。这个就有点费解了，对一个 volatile 变量的写操作相对于后续对这个 volatile 变量的读操 作可见，这怎么看都是禁用缓存的意思啊，貌似和 1.5 版本以前的语义没有变化啊？如果 单看这个规则，的确是这样，但是如果我们关联一下规则 3，就有点不一样的感觉了。

3、传递性规则

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

我们将规则 3 的传递性应用到我们的例子中，会发生什么呢？可以看下面这幅图：

从图中，我们可以看到：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” ，有没有一种恍然大悟的感觉？这就是 1.5 版本对 volatile 语义的增强，这个增强意义重大，1.5 版本的并发工具包（java.util.concurrent） 就是靠 volatile 语义来搞定可见性的，这个在后面的内容中会详细介绍。

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

本期题目来源：王宝令大神的《Java并发编程实战》，有兴趣的可以购买极客时间的对应课程哦~。

关注强哥，一起加油，一起提升。

关注公众号获取更多内容，有问题也可在公众号提问哦：

强哥叨逼叨

叨逼叨编程、互联网的见解和新鲜事