小姐姐都能看懂的Happens-before规则，你还愣住了

前言

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

可见性：正是由于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()方法，如下图：

添加图片注释，不超过 140 字（可选）

传递性示例图

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

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线程是可见的。如下图：

添加图片注释，不超过 140 字（可选）

管程中锁示例图

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内存模型中的作用不可小觑，你看懂了吗？

                                                                                                                                             资源获取：
大家 点赞、收藏、关注、评论啦 、 查看👇🏻👇🏻👇🏻 微信公众号获取联系方式👇🏻👇🏻👇🏻
精彩专栏推荐订阅：在 下方专栏👇🏻👇🏻👇🏻👇🏻
每天学四小时：Java+Spring+JVM+分布式高并发，架构师指日可待