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 规则有关的哪些规则？

1. 程序的顺序性规则

2. volatile 变量规则

3. 传递性

4. 管程中锁的规则

5. 线程 start() 规则

6. 线程 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。

  

   

   

  X=42对写变量v=true是可见的

  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？

• volatile

• 管程，也就是放入sychronized代码块中

• join()方法