敞开成长之旅！这是我参与「日新计划 12 月更文挑战」的第 36 天，点击检查活动概况

我是石页兄，朋友不因远而疏，高山不隔友谊情；偶遇美羊羊，咱们互相鼓舞

欢迎重视微信大众号「架构染色」沟通和学习

一、重视运用效果而非底层完成

前文《原来了解重排序是为了掌握可见性的保证》、《运行期重排序：内存体系的重排序》、《防止重排序之运用 Volatile 关键字》中整理了一部分重排序对可见性的影响，这些内容仅仅确保可见性的一小部分内容，笔者本身还对寄存器缓存和指令并行重排等许多细节有疑问。应该不少读者教师也能感受到整理清楚一切的细节真的是相当有难度的。

作为上层高级言语程序员，确实很难掌握悉数底层的情况。更希望结合 java 语法，以运用的视角经过一种更简略的方式来掌握怎么确保可见性，而不是 怎么完成可见性确保。 确保可见性的完成是 JMM 自己的工作，而不是程序员的。而 JMM 的 happens-before 的概念便是这个效果，规范程序员怎么运用以保证可见性。

从 JDK5 开端 java 运用新的 JSR -133 内存模型，并依据此内存模型提出了 happens-before 的概念，经过这个概念来论述操作之间的内存可见性。程序员要确保可见性，便是恪守 Happens-Before 规矩，合理的运用 java 提供的东西。

遵循Happens-Before规则来保证可见性|而非掌握所有底层

二、Happens-Before 概念

Java 内存模型中指定的 Happens-Before 规矩，Happens-Before 规矩开端是在一篇叫做 Time, Clocks, and the Ordering of Events in a Distributed System 的论文中提出来的，在这篇论文中，Happens-Before 的语义是一种因果联系。在现实世界里，假如 A 事情是导致 B 事情的原因，那么 A 事情一定是先于（Happens-Before）B 事情产生的，这个便是 Happens-Before 语义的现实了解。

在 Java 言语里边，Happens-Before 的语义本质上是一种可见性，A Happens-Before B 意味着 A 事情对 B 事情来说是可见的，无论 A 事情和 B 事情是否产生在同一个线程里。例如 A 事情产生在线程 1 上，B 事情产生在线程 2 上，Happens-Before 规矩确保线程 2 上也能看到 A 事情的产生

三、Java 原生存在的 Happens-Before 规矩

下边这 8 条规矩是 Java 内存模型下存在的原生 Happens-Before 联系，无需借助任何同步器协助就现已存在，能够在编码中直接运用。

  1. 程序次第规矩（Program Order Rule） 在一个线程内，依照程序代码次第，书写在前面的操作 Happens-Before 书写在后面的操作

  2. 管程确定规矩（Monitor Lock Rule） An unlock on a monitor happens-before every subsequent lock on that monitor. 一个 unlock 操作 Happens-Before 后面对同一个锁的 lock 操作。思考，不是同一个锁就不确保了吗？是的

    synchronized (this) { //此处主动加锁
  // x是同享变量,初始值=10
  if (this.x < 12) {
    this.x = 12;
  }
} //此处主动解锁
//管程中锁的规矩，能够这样了解：
//假定x的初始值是10，线程A执行完代码块后x的值会变成12（执行完主动开释锁），
//线程B进入代码块时，能够看到线程A对x的写操作，也便是线程B能够看到x==12

  3. volatile 变量规矩（volatile Variable Rule） A write to a volatile field happens-before every subsequent read of that volatile. 对一个 volatile 变量的写入操作 Happens-Before 后面对这个变量的读操作。

  4. 线程发动规矩（Thread Start Rule） Thread 目标的 start()办法 Happens-Before 此线程的每一个动作。

    Thread B = new Thread(()->{
  // 主线程调用B.start()之前
  // 一切对同享变量的修正，此处皆可见
  // 此例中，var==77
});
// 此处对同享变量var修正
var = 77;
// 主线程发动子线程
B.start();

  5. 线程停止规矩（Thread Termination Rule） 线程中的一切操作都 Happens-Before 对此线程的停止检测。

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

  6. 线程中止规矩（Thread Interruption Rule） 对线程 interrupt()办法的调用 Happens-Before 被中止线程的代码检测到中止事情的产生，能够经过 Thread.interrupt()办法检测到是否有中止产生。

  7. 目标完结规矩（Finalizer Rule） 一个目标的初始化完成（结构函数执行结束）Happens-Before 它的 finalize()办法的开端。

  8. 传递性（Transitivity） 偏序联系的传递性：假如已知 hb(a,b)和 hb(b,c)，那么咱们能够推导出 hb(a,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会是多少呢？ } } } 根据程序次第规矩 + volatile 变量规矩+传递性，咱们得到结果：“x=42” Happens-Before 读变量“v=true”。这意味着什么呢？

    遵循Happens-Before规则来保证可见性|而非掌握所有底层

在 Java 言语中无需任何同步手法保证就能成立的先行产生规矩就只有上面这些了。

四、推导更多的 Happens-Before

Java 中原生满意 Happens-Before 联系的规矩就只有上述 8 条，可是还能够经过它们推导出其它的满意 Happens-Before 的操作，如：

  1. 将一个元素放入一个线程安全的行列的操作 Happens-Before 从行列中取出这个元素的操作
  2. 将一个元素放入一个线程安全容器的操作 Happens-Before 从容器中取出这个元素的操作
  3. 在 CountDownLatch 上的倒数操作 Happens-Before CountDownLatch#await()操作
  4. 开释 Semaphore 许可的操作 Happens-Before 获得许可操作
  5. Future 表明的使命的一切操作 Happens-Before Future#get()操作
  6. 向 Executor 提交一个 Runnable 或 Callable 的操作 Happens-Before 使命开端执行操作
  7. 假如两个操作之间不存在上述的 Happens-Before 规矩中的任意一条，并且也不能经过已有的 Happens-Before 联系推到出来，那么这两个操作之间就没有次第性的保证，虚拟机能够对这两个操作进行重排序！

假如存在 hb(a,b)，那么操作 a 在内存上面所做的操作（如赋值操作等）都对操作 b 可见，即操作 a 影响了操作 b。

五、最终说一句

我是石页兄，假如这篇文章对您有帮助，或者有所启示的话，欢迎重视笔者的微信大众号【 架构染色 】进行沟通和学习。您的支撑是我坚持写作最大的动力。

欢迎点击链接扫马儿重视、沟通。

参阅并感谢

  • ifeve.com/from-single…
  • Java 并发编程实战