【并发编程实战】内存模型--解决可见性和有序性的利器

一.前言

在前面讲了三个问题，缓存导致的可见性问题，编译优化带来的有序性问题，线程切换带来的原子性问题。既然存在问题，那么总要有解决方案的，这一章里主要就是解决这三个问题的关键点--内存模型

二.内存模型

2.1 定义：规范了 JVM 如何提供按需禁用缓存和编译优化的方法。

2.2 解释：缓存和编译优化导致的可见性和有序性问题，如果把缓存和编译优化禁止掉，程序的性能就大大降低。为了避免这种情况，java提供了内存模型的概念来解决能够按照需要进行禁用缓存和编译优化。

2.3 具体：这些方法包括 volatile、synchronized 和 final 三个关键字，以及六项 Happens-Before 规则

三.Happens-Before 六项规则

定义：Happens-Before 约束了编译器的优化行为，虽允许编译器优化，但是要求编译器优化后一定遵守 Happens-Before 规则。前面一个操作的结果对后续操作是可见的。

1. 程序的顺序性规则

volatile 变量 volatile boolean v = false，它表达的是：告诉编译器，对这个变量的读写，不能使用 CPU 缓存，必须从内存中读取或者写入。

happens-before并不是先发生，而是操作对后可见，因为如果不存在volatile的话，v=true有可能在x=42之前执行，而文中这句话的意思是，'x = 42' 的执行结果，在 'v=true' 的时候是可见的，也就是说在'v=true'的时候，我们可以认为此时x已经等于42，但只不过这段代码里，'v=true'并不依赖于'x=42'的结果，因此编译器认为做一次重排序没什么问题，所以有可能会做重排序。

例如下面的示例代码，假设线程 A 执行 writer() 方法，按照 volatile 语义，会把变量 “v=true” 写入内存；假设线程 B 执行 reader() 方法，同样按照 volatile 语义，线程 B 会从内存中读取变量 v，如果线程 B 看到 “v == true” 时，那么线程 B 看到的变量 x 是多少呢？直觉上看，应该是 42，那实际应该是多少呢？这个要看 Java 的版本，如果在低于 1.5 版本上运行，x 可能是 42，也有可能是 0；如果在 1.5 以上的版本上运行，x 就是等于 42。1.5以上的版本根据顺序性规则做了优化

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

2. volatile 变量规则

volatile 关键字有两个主要作用：确保可见性和禁止指令重排序。为了实现这些特性，特别是在volatile写的操作中，Java内存模型会在写操作前后自动插入内存屏障。这个过程可以用以下步骤和示意图要点来概述：

前 Store 屏障（Store Store Barrier）: 在volatile写操作执行前，会先插入一个Store Store屏障。这个屏障确保了在volatile写之前的所有普通内存写操作（非volatile的）都已经完成并刷新到主内存中。这样就确保了volatile变量的最新值不会被之前的写操作所覆盖。
volatile 写操作: 执行volatile变量的写入操作，将更新后的值写入主内存中。
后 Store 屏障（Store Load Barrier）: 在volatile写操作之后，会插入一个Store Load屏障。这个屏障有两个作用：首先，它确保当前的volatile写操作在任何后续的读操作（包括非volatile读）之前完成；其次，它也作为一个信号点，告知其他线程当前线程已经完成了volatile变量的写入，从而保证了写操作的可见性。
volatile 写示意图

5.volatile 读示意图

3. 传递性

这条规则是指如果 A 的操作结果对 B的操作是可知的，且 B 的操作结果对 C的后续操作也是可知的，那么 A 的操作结果则对 C后续操作也是可知的，这就是传递性

还是以 1 规则里的代码来分析：

1.“x=42” Happens-Before 写变量 “v=true” ，这是规则 1 的内容；

2.写变量“v=true” Happens-Before 读变量 “v=true”，这是规则 2 的内容。

3.再根据这个传递性规则，我们得到结果：“x=42” Happens-Before 读变量“v=true”。这意味着什么呢？如果线程 B 读到了“v=true”，那么线程 A 设置的“x=42”对线程 B 是可见的。也就是说，线程 B 能看到 “x == 42”

总结：

顺序性规则+传递行规则+volatile规则来推断，边界就是只要给volatile赋值成功，那么这个赋值语句之前所有代码的执行结果都对其他线程可见所以应该是将有volitile执行结果的cpu全部缓存强制刷新到内存，然后强制将其它cpu中的全部缓存和内存同步。所以这个赋值语句之前所有代码的执行结果都对其他线程可见

4. 管程中锁的规则

它指的是用于实现线程间同步与互斥的一套机制。管程的核心思想是将共享资源与访问这些资源的代码封装在一起，并通过一个锁（通常与一个条件变量相结合）来控制对资源的访问，以此来保证并发安全。Java中的管程机制主要是通过synchronized关键字和java.util.concurrent.locks包下的类（如ReentrantLock, Condition等）来实现的。

具体来说，Java中的管程特性包括：

互斥性：同一时刻只允许一个线程进入管程保护的代码区域，防止多个线程同时对共享资源进行修改，这是通过内置的监视器锁（monitor lock）或显式的Lock对象来实现的。
条件变量：允许线程在满足特定条件之前等待，并在条件满足时被唤醒。在Java中，Object类提供的wait(), notify(), 和 notifyAll()方法，以及Condition接口，都服务于这一目的。
线程安全：管程内部的代码是线程安全的，因为对共享资源的访问受到了严格的控制。
内存可见性：进入管程的线程可以看到管程中变量的最新值，这是因为监视器锁确保了对内存的写操作先行发生于后续的读操作，符合Java内存模型的规定。

通过使用管程，开发者可以构建更易于理解和维护的并发程序，减少因竞态条件导致的错误。实际上，当我们在Java中使用synchronized关键字标记方法或代码块时，就是在创建一个简单的管程结构，确保了同步和互斥的正确实施。

5. 线程 start() 规则

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

6. 线程 join() 规则

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