我所理解的JMM--4 happen-before

妖狐艹你老母 2023-03-04 08:09 12阅读 0赞

### Happen-Before 概述 ###

> `Happen-Before`后文简写为`HB`.  
> Happens-Before 关系 两个动作（action）可以被 happens-before 关系排序。如果一  
> 个动作 happens-before 另一个动作，则第一个对第二个可见，且第一个排在第二个  
> 之前。

`HB`是`JMM`核心规范之一。大致规范如下几条：  
(1) 单线程上下行代码：一个线程中的每个操作，`happens-before`于该线程中的任意后续操作。  
(2) 同步加解锁: 对一个锁的解锁，`happens-before`于随后对这个锁的加锁。  
(3) `volatile`: 对一个`volatile`域的写，`happens- before`于任意后续对这个`volatile`域的读。  
(4) 传递性: 如果`A happens-before B`，且`B happens-before C`，那么`Ahappens-before C`。  
(5) `start()`规则：如果线程A执行操作`ThreadB.start()`（启动线程B），那么A线程的`ThreadB.start()`操作`happens-before`于`线程B`中的任意操作。  
(6) `join()`规则：如果线程A执行操作`ThreadB. join()`并成功返回，那么线程B中的任意操作`happens-before`于线程A从`ThreadB. join()`操作成功返回。

容易理解出错的地方如下：

1.  上述规范是给编写java层级的程序的看的，并非给`编译器/虚拟机`作者，也就是说如果`编译器/虚拟机`可保证可见性那么可以任意重排序执行。
2.  `HB`并不是保证运行的先后顺序，可是内存可见性。如果`A`操作`happen-before` 于`B`,假设如果先执行了`A`，后执行`B`(多线程环境)，那么必须保证`B操作`能看到`A操作`的的内存变化。
3.  `HB`关系可以在多线程使用而并不是单线程下。

**举例说明HB案例：**

**案例一:**

(1) 单线程上下行代码：一个线程中的每个操作，`happens-before`于该线程中的任意后续操作。

public class Main {
        
        public static void main(String[] args) {
        
            int varOne = 2;
            //由于 varOne ， varTwo 存在hb关系,即 一个线程中的每个操作，`happens-before`于该线程中的任意后续操作。
            // 所以 varTwo一定可以看到 varOne=2
            int varTwo = varOne;
        }
    }

**案例二:**

(2) 同步加解锁: 对一个锁的解锁，`happens-before`于随后对这个锁的加锁。

public class Main {
        
        static int flag = 0;
        public static void main(String[] args) throws InterruptedException {
        
    
            new Thread(() -> {
        
                synchronized (Math.class) {
        
                    flag = 2;
                }
            }).start();
            
            //粗略保证子线程  flag=2
            int i = 0;
            while (++i <100) {
        
            }
            //等候子线程解锁Math对象，然后加锁Math
            //此处存在hb 关系。(2) 同步加解锁: 对一个锁的解锁，`happens-before`于随后对这个锁的加锁。
            //所以此处 一定可以看到子线程 更新了 flag = 2;
            synchronized (Math.class) {
        
                System.out.printf("%s", flag);
            }
    
        }
    }

**案例三:**

(3) `volatile`: 对一个`volatile`域的写，`happens- before`于任意后续对这个`volatile`域的读。

import java.util.concurrent.TimeUnit;
    
    public class Main {
        
        static volatile int flag = 0;
    
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(() -> {
        
                flag = 2;
            }).start();
            //粗略保证子线程  flag=2
            int i = 0;
            while (++i <100) {
        
            }
    
            //此处存在hb 关系。 `volatile`: 对一个`volatile`域的写，`happens- before`于任意后续对这个`volatile`域的读。
            //所以此处 一定可以看到子线程 更新了 flag = 2,而不是输出0
            System.out.printf("%s", flag);
    
        }
    }

**案例4:**  
(4) 传递性: 如果`A happens-before B`，且`B happens-before C`，那么`Ahappens-before C`。

import java.util.concurrent.TimeUnit;
    
    public class Main {
        
        static volatile int flag = 0;
        static int commonFlag = 0;
        public static void main(String[] args) throws InterruptedException {
        
    
            new Thread(() -> {
        
                commonFlag = 2;
                //注意commonFlag 和flag也存在一个flag，happen-before
                flag = 2;
            }).start();
    
            //粗略保证子线程  flag=2
            int i = 0;
            while (++i < 100) {
        
            }
    
            //此处存在hb 关系。 `volatile`: 对一个`volatile`域的写，`happens- before`于任意后续对这个`volatile`域的读。
            //所以此处 一定可以看到子线程 更新了 flag = 2,而不是输出0
            System.out.printf("%s", flag);
            //由于 （1） commFlag写 hb volatile flag写
            //     (2) volatile flag写  hb volatile flag读
            //     (3) volatile flag 读 hb  commonFlag 读
            //    综上（1）(2)(3)结合传递性原则，得到 (4) commonFlag 读hb commonFlag写
            System.out.printf("%s", commonFlag);
    
        }
    }

如果抽象请看下图:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70]

**案例5:**  
(5) `start()`规则：如果线程A执行操作`ThreadB.start()`（启动线程B），那么A线程的`ThreadB.start()`操作`happens-before`于`线程B`中的任意操作。

public class Main {
        
        static int commonFlag = 0;
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(() -> {
        
                commonFlag = 2;
            }).start();
    
            //粗略保证子线程  commonFlag=2
            int i = 0;
            while (++i < 100) {
        
            }
            // `start()`规则：如果线程A执行操作`ThreadB.start()`（启动线程B），那么A线程的`ThreadB.start()`操作`happens-before`于`线程B`中的任意操作。
            System.out.println(commonFlag + "");
        }
    }

**案例6:**  
(6) `join()`规则：如果线程A执行操作`ThreadB. join()`并成功返回，那么线程B中的任意操作`happens-before`于线程A从`ThreadB. join()`操作成功返回。

public class Main {
        
        static int commonFlag = 0;
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(() -> {
        
                commonFlag = 2;
            }).join();
    
            // 由于join存在所以一定会初始 2 而不是0
            System.out.println(commonFlag + "");
        }
    }

### Happen-Before 内存实现 ###

`HB`可以依靠`内存屏障`实现内存上的可见性,内存屏障相关知识点可参考[我所理解的JMM–3 内存屏障][JMM_3]

回顾`HB`的`JMM`核心几条规范，我们可以得到如下的重排序规则：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 1]

举例第2行第4列第一个参数为`普通读/普通写` 第二个操作数为 `volatile`为何可以从`HB`中推导出不可以重排序。

我们看如下代码

我们知道`HB`有以下原则:

(1) `volatile`: 对一个`volatile`域的写，`happens- before`于任意后续对这个`volatile`域的读。  
(2) 传递性: 如果`A happens-before B`，且`B happens-before C`，那么`Ahappens-before C`。  
(3) 单线程上下行代码：一个线程中的每个操作，`happens-before`于该线程中的任意后续操作。

上述代码中：  
通过HB原则我们可以得到以下关系：

`(1) 第8行 hb 第10行`  
`(2) 第10行 hb 第18行`  
`(3) 第18行 hb 第20行`  
`(4) 第8行 hb 第20行（传递性得到)`

在单线程环境中第8行和第10行互换位置运行，其实并不会破坏单线程语义，而多线程环境下将会破坏`HB`传递性原则，导致`(4) 第8行 hb 第20行（传递性得到）`将会失效，用户可能此时会在`18`行看到输出`2`，而`20`行输出`0`。

综上所述 第8行和第10行禁止交换位置运行。

**我们再来看看这个例子中如何插入内存屏障实现HB效果:**

public class Main {
        
        static int commonFlag = 0;
        static volatile int volatileVar = 0;
    
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(() -> {
        
                //第8行
                commonFlag = 2;
                //STORESTORE屏障 屏障在执行volatileVar = 2;时 commonFlag已经刷新回主内存
                //第10行  volatileVar 由于是volatile修饰的 所以会直接刷回主内存
                volatileVar = 2;
    
            }).start();
    
            int i = 0;
            //粗略的让子线程子线程执行完成后在执行后续操作
            while (i++ < 100) {
        
            }
    
            //第18行  volatileVar 由于是volatile修饰的所以直接从主内存中读取
            System.out.println(volatileVar);
            //LOADLOAD 保证commonFlag 读取到最新的数值
            //第20行
            System.out.println(commonFlag);
        }
    }

上述例子中如果能读取volatileVar=2，那么一定可以保证commonFlag读取也是2。

我们再来看一个更复杂的例子（例子来自并发大师Doug Lea 文章[The JSR-133 Cookbook for Compiler Writers][]）：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 2]

以下直接给出其他防止重排序插入的内存屏障类型：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 3]  
由于解锁加锁/解锁不是内存屏障实现而是JVM关键字实现所以可以得到细化版本：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 4]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70]: /images/20230208/c8ad669be2bd4d45b40993dc6639c2fa.png
[JMM_3]: https://blog.csdn.net/qfanmingyiq/article/details/107449052
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 1]: /images/20230208/1c9b0c6f3c1d48618e619a4002b43ca6.png
[The JSR-133 Cookbook for Compiler Writers]: http://gee.cs.oswego.edu/dl/jmm/cookbook.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 2]: /images/20230208/7da28cb6fc1d4f8b8ead863d3ea5900b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 3]: /images/20230208/163d5086d13e47838eb700cc6b1c3665.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 4]: /images/20230208/ac9a21c20eef4194be819d840a9cfb6a.png