[Java并发-2]Java如何解决可见性问题的

以前咱们说了：
1，可见性
2，原子性
3，有序性
3个并发BUG的之源，这三个也是编程领域的共性问题。Java诞生之处就支持多线程，因此天然有解决这些问题的办法，并且在编程语言领域处于领先地位。理解Java解决并发问题的方案，对于其余语言的解决方案也有举一反三的效果。

什么是Java内存模型

咱们已经知道了，致使可见性的缘由是缓存，致使有序性的问题是编译优化。那解决问题的办法就是直接禁用 缓存和编译优化。可是直接不去使用这些是不行了，性能没法提高。
因此合理的方案是 按需禁用缓存和编译优化。如何作到“按需禁用”，只有编写代码的程序员本身知道，因此程序须要给程序员按需禁用和编译优化的方法才行。

Java的内存模型若是站在程序员的角度，能够理解为，Java内存模型规范了JVM如何提供按需禁用缓存和编译优化的方法。具体来讲，这些方法包括volatile,synchronized和final三个关键字段。
以及六项 Happens-Before 规则。

使用volatile的困惑

volatile 关键字并非 Java 语言特有的，C语言也有，它的原始意义就是禁用CPU缓存。

例如，咱们声明一个volatile变量 ，volatile int x = 0，它表达的是：告诉编译器，对这个变量的读写，不能使用 CPU 缓存，必须从内存中读取或者写入。看起来语义很明确，实际状况比较困惑。

看下如下代码：

class VolatileExample {

  int x = 0;

  volatile boolean v = false;

  public void writer() {

    x = 42;

    v = true;

  }

  public void reader() {

    if (v == true) {

      // 这里 x 会是多少呢？

    }

  }

}

直觉上看，这里的X应该是42，那实际应该是多少呢？这个要看Java的版本，若是在低于 1.5 版本上运行，x 多是42，也有多是 0；若是在 1.5 以上的版本上运行，x 就是等于 42。
分析一下，为何 1.5 之前的版本会出现 x = 0 的状况呢？由于变量 x 可能被 CPU 缓存而致使可见性问题。这个问题在 1.5 版本已经被圆满解决了。Java 内存模型在 1.5 版本对 volatile 语义进行了加强。怎么加强的呢？答案是一项 Happens-Before 规则。

Happens-Before 规则

这里直接给出定义：

Happens-Before ：前面一个操做的结果对后续操做是可见的。

再进一步的讲：Happens-Before 约束了编译器的优化行为，虽容许编译器优化，可是要求编译器优化后必定遵照 Happens-Before 规则。

看一看Java内存模型定义了哪些重要的Happens-Before规则

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

2，volatile 变量规则

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

这个就有点费解了，对一个 volatile 变量的写操做相对于后续对这个 volatile 变量的读操做可见。

3，传递性

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

咱们将规则 3 的传递性应用到咱们的例子中，能够看下面这幅图：

class VolatileExample {

  int x = 0;

  volatile boolean v = false;

  public void writer() {

    x = 42;

    v = true;

  }

  public void reader() {

    if (v == true) {

      // 这里 x 会是多少呢？

    }

  }

}

从图中能够看到
1，x=42 Happens-Before 写 v=true，这是规则1
2，读v=true Happens-Before 读变量X，这是规则2

结合传递性读定义，即：

线程A的 x=42 Happens-Before 线程B的 读变量X

java 1.5对 volatile 的加强就是这个，根据这个定义就保证了以前的 x=42的成立

4，管程中锁的规则

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

管程 (英语：Moniters，也称为监视器) 是一种程序结构，结构内的多个子程序（对象或模块）造成的多个工做线程互斥访问共享资源。

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

synchronized (this) { // 此处自动加锁

  // x 是共享变量, 初始值 =10

  if (this.x < 12) {

    this.x = 12; 

  }  

} // 此处自动解锁

因此结合规则定义，能够这样理解：假设 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

过分优化的 final

前面咱们讲 volatile 为的是禁用缓存以及编译优化，那 final关键字 就是告诉编译器优化得更好一点。

final 修饰变量时，初衷是告诉编译器：这个变量生而不变，能够尽可能优化。可是Java编译器在 1.5 之前的版本致使优化错误了。

构造函数的错误重排致使线程可能看到 final 变量的值会变化。详细的案例能够参考：http://www.cs.umd.edu/~pugh/j...

固然了，在 1.5 之后 Java 内存模型对 final 类型变量的重排进行了约束。如今只要咱们提供正确构造函数没有“逸出”，就不会出问题了。

在下面例子中，在构造函数里面将 this 赋值给了全局变量 global.obj，这就是“逸出”，线程经过 global.obj 读取 x 是有可能读到 0 的。所以咱们必定要避免“逸出”。

final int x;

// 错误的构造函数

public FinalFieldExample() { 

  x = 3;

  y = 4;

  // 此处就是讲 this 逸出，

  global.obj = this;

}

总结

Java 的内存模型是并发编程领域的一次重要创新，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 内存模型主要分为两部分，一部分面向你我这种编写并发程序的应用开发人员，另外一部分是面向 JVM 的实现人员的，咱们能够重点关注前者，也就是和编写并发程序相关的部分，这部份内容的核心就是 Happens-Before 规则。

参考：
Java内存模型