Java内存模型：看Java如何解决可见性和有序性问题

1）导致可见性的原因是缓存，导致有序性的原因是编译优化，那我们最直接的解决可见性和有序性的方案是什么？

禁用缓存和编译优化

2）1是暴力解法，虽然问题解决了，但是性能拉跨了，那合理的解决方案是什么？

按需禁用缓存以及编译优化

3）如何做到“按需禁用”呢？

所谓“按需禁用”其实就是指按照程序员的要求来禁用
需要提供给程序员按需禁用缓存和编译优化的方法。

4）什么是Java内存模型？

它规范了 JVM 如何提供按需禁用缓存和编译优化的方法给我们程序员。
包括 volatile、synchronized 和 final 三个关键字，以及六项 Happens-Before 规则。

5）volatile 关键字是Java的特产吗？

并不是 Java 语言的特产，古老的 C 语言里也有，它最原始的意义就是禁用 CPU 缓存。

6）volatile int x = 0是什么含义？

告诉编译器，对这个变量的读写，不能使用 CPU 缓存，必须从内存中读取或者写入。

7）下面代码中假如A先执行writer()方法，接着B线程执行reader()方法，那B中看到的X的值应该是多少？


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

1.5以前的版本x 可能是 42，也有可能是 0。
1.5 以上的版本上运行，x 就是等于 42

8）为什么 1.5 以前的版本会出现 x = 0 的情况呢？

变量 x 可能被 CPU 缓存而导致可见性问题

9）那1.5之后做了哪些改变解决了这个隐形bug呢？

对 volatile 语义进行了增强—-Happens-Before 规则。

10）什么是Happens-Before 规则？

前面一个操作的结果对后续操作是可见的，就像有心灵感应的两个人，虽然远隔千里，一个人心之所想，另一个人都看得到。两个线程之间有了这种心灵感应，变得更加亲密了。

11）我们程序员应该掌握与Happens-Before 规则有关的哪些规则？

程序的顺序性规则
volatile 变量规则
传递性
管程中锁的规则
线程 start() 规则
线程 join() 规则

11.1）程序的顺序性规则是什么意思？

在一个线程中，按照程序顺序，前面的操作 Happens-Before 于后续的任意操作。（第 6 行代码 “x = 42;” 对第 7 行代码 “v = true“是可见的;

11.2）volatile 变量规则是什么意思？

对一个 volatile 变量的写操作， Happens-Before 于后续对这个 volatile 变量的读操作。
对一个 volatile 变量的写操作相对于后续对这个 volatile 变量的读操作可见，这怎么看都是禁用缓存的意思啊，我们结合下面的传递性来看。

11.3）传递性是什么意思？

A Happens-Before B，且 B Happens-Before C，那么 A Happens-Before C。
1. 写变量v=true对读变量v=true是可见的
2. 则x=42对读变量v=true是可见的
这就是 1.5 版本对 volatile 语义的增强，这个增强意义重大

11.4）什么是管程？

线程之间要实现同步说的话，在 Java 中指的就是 synchronized，synchronized 是 Java 里对管程的实现

11.5）管程中锁的规则是什么意思？

对一个锁的解锁 Happens-Before 于后续对这个锁的加锁。
解锁后我锁住期间干的事对后续线程是可见的
```
synchronized (this) { //此处自动加锁
 // x是共享变量,初始值=10
 if (this.x < 12) {
  this.x = 12; 
  } 
} //此处自动解锁
```
x 的初始值是 10，线程 A 执行完代码块后 x 的值会变成 12（执行完自动释放锁），线程 B 进入代码块时，能够看到线程 A 对 x 的写操作，也就是线程 B 能够看到 x==12

11.6)线程 start() 规则是什么意思？

主线程 A 启动子线程 B 后，子线程 B 能够看到主线程在启动子线程 B 前的操作。


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

main线程在启动B线程之前，把var值修改为77，对我们的线程B是可见的。

11.7）线程 join() 规则是什么意思？

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


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

12)前面我们都是在讲volatile目的是禁用缓存以及编译优化，那我们可不可以告诉编译器让它主动的去优化的更好一点，不要让我去操心？

final 关键字

13）final关键字是什么含义？

final 修饰变量时，目的是告诉编译器：这个变量生而不变，可以最大努力的优化。但是1.5版本之前呢发力过猛了，以至于出现很多的bug。

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

14）什么是逸出呢？

逸出指的是对封装性的破坏。比如对一个对象的操作，通过将这个对象的this赋值给一个外部全局变量，使得这个全局变量可以绕过对象的封装接口直接访问对象中的成员，这就是逸出.
```
// 以下代码来源于【参考1】
final int x;
// 错误的构造函数
public FinalFieldExample() { 
  x = 3;
  y = 4;
  // 此处就是讲this逸出，
  global.obj = this;
}
```
一句话：有内鬼，位置暴露。

15）有一个共享变量 abc，在一个线程里设置了 abc 的值 abc=3，你思考一下，有哪些办法可以让其他线程能够看到abc==3？