没有Happens-Before？你的多线程代码就是‘一锅粥’！

内存模型与happens-before：开发者与硬件的和平条约

在前文中，提到处理器通过一些特殊指令（如 LOCK、CMPXCHG、内存屏障等）来保障多线程环境下程序的正确性。然而，这种做法仍然存在几个显著问题。

1）底层指令实现复杂且晦涩：处理器指令的细节往往难以理解，开发者需要付出大量的时间和精力来掌握这些低级实现。

2）不同平台间的兼容性问题：不同硬件架构和操作系统对这些指令的支持和实现方式各不相同，这要求程序在设计时考虑到跨平台的兼容性和一致性。

3）多线程数据操作的复杂性：随着程序业务逻辑的多变，处理器与线程之间的内存访问依赖关系变得更加复杂，从而增加了程序出错的风险。

为了简化并发编程，解决这些问题，现代编程语言通常提供了抽象的内存模型，用以规范多线程环境下的内存访问行为。这种抽象使开发者无需关注底层硬件与操作系统实现细节，即可编写高效且可移植的并发程序。

以 Java 为例，Java语言采用了Java 内存模型（Java Memory Model，JMM）来提供这种抽象。 Java 内存模型的核心目的是通过支持诸如 volatile、synchronized、final 等同步原语，来确保在多线程环境下程序的原子性、可见性和有序性。这些原语确保了不同线程间的操作能够按照特定的规则正确协作。

此外，JMM 还引入了一个重要概念：happens-before 关系，旨在描述并发编程中操作之间的偏序关系。具体来说，偏序关系主要用于确保线程间操作的顺序性，避免因执行顺序不明确而导致的并发问题。

偏序关系在并发编程中的应用主要体现在以下两种情况。

1）程序顺序（Program Order）：指单线程中，由程序控制流决定的操作顺序。例如，如果操作 A 在操作 B 之前执行，那么我们可以认为 A <= B。

2）同步顺序（Synchronization Order）：指由并发控制机制（如锁、信号量等）所控制的操作顺序。例如，如果操作 A 释放了锁，而操作 B 随后获取了该锁，那么我们可以认为 A <= B。

除了 Java 之外，其他现代编程语言，如 Go、C++、Rust 等，也都实现了各自的 happens-before 关系机制，以确保并发程序的正确性和一致性。

Java内存模型的happens-before关系是用来描述两个线程操作的内存可见性。需注意这里的可见性，并不代表A线程的执行顺序一定早于B线程， 而是A线程对某个共享变量的操作对B线程可见。即A线程对变量a进行写操作，B线程读取到是变量a的变更值。

Java内存模型定义了主内存（Main memory），本地内存（Local memory），共享变量等抽象关系，来决定共享变量在多线程之间通信同步方式，即前面所说两个线程操作的内存可见性。其中本地内存，涵盖了缓存，写缓冲区，寄存器以及其他硬件和编译器优化等概念。

如图所示，如果线程A与线程B之间要通信的话，必须要经历下面2个步骤：

1）线程A把本地内存A中更新过的共享变量刷新到主内存中；

2）线程B到主内存中去读取线程A之前已更新过的共享变量。

为了进一步抽象这种线程间的数据同步方式，Java内存模型定义了下述线程间的happens-before关系。

1）程序顺序规则：单线程内，每个操作happens-before于该线程中的任意后续操作。

// Thread1内, A happens-before B，B happens-before C。
// 这意味着A一定会在B之前完成，B一定会在C之前完成。因此，可以确信y包含x+5的结果。
Thread1 {
    x = 10;    // A
    y = x + 5; // B
    print(y);  // C
}

2）监视器锁规则：释放锁的操作happens-before之后对同一把锁的获取的锁操作。

// Thread1释放锁（B）happens-before Thread2获取锁（C）。
// 这意味着当Thread2打印x时，它看到的一定是"Thread1 data"，因为Thread1的修改操作和释放锁操作，都在Thread2获取锁之前完成。
lock = Lock() 

Thread1 {
    lock.acquire() 
    x = "Thread1 data" // A
    lock.release() // B
}

Thread2 {
    lock.acquire() // C
    print(x) // D
    lock.release() 
}

3）volatile变量规则：volatile字段的写操作happens-before之后对同一字段的读操作。

// 对volatile字段的写操作（A）happens-before之后对同一字段的读操作（B）。
// 这意味着当Thread2读取x时，它看到的一定是100，因为Thread1的写操作在Thread2的读操作之前完成。
volatile int sharedData; // 声明一个volatile变量

Thread1 {
    x = 100; // A
}

Thread2 {
    int localData = x; // B
    print(localData);
}

4）传递性规则：如果A happens-before B，且B happens-before C，那么A happens-before C。

// 如果Thread1 A happens-before Thread2 B，且Thread2 B happens-before Thread2 C，那么Thread1 A happens-before Thread2 C。
// 这意味着A一定会在C之前完成。因此，可以确信z包含(x+5)*2的结果，因为赋值给x的操作和计算x+5的操作都在计算y*2的操作之前完成。
Thread1 {
    x = 10;    // A
}

Thread2 {
    y = x + 5; // B
    z = y * 2; // C
    print(z);  
}

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

// 如果Thread1执行操作ThreadB.start()，那么Thread1 A happens-before Thread2 C。
// 这意味着A一定会在C之前完成。因此，可以确信Thread1 x值为10，因为赋值给x的操作在打印x的操作之前完成。
Thread1 {
    ThreadB.start(); // A
    x = 10; // B
}

Thread2 {
    print(x); // C
}

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

// 如果线Thread1执行操作Thread2.join()，那么Thread2 D happens-before Thread1 C。
// 这意味着D一定会在C之前完成。因此，可以确信Thread1 x值为10，因为赋值给x的操作在打印x的操作之前完成。
Thread1 {
    Thread2.start(); // A
    Thread2.join();  // B
    print(x);        // C
}

Thread2 {
    x = 10;          // D
}

如上的happens-before关系中，与日常开发密切相关的是1、2、3、4四个规则。其中规则1满足了as-if-serial语义，即Java内存模型允许代码和指令重排序，只要不影响程序执行结果。规则2和3是通过synchronized、volatile关键字实现。结合规则1、2、3来看看规则4的具体使用，可以看到如下的代码，程序最终执行且得到正确结果。

// x, y, z被volatile关键字修饰
private volatile int x, y, z; 
    
public void test() {
    Thread a = new Thread(() -> {
        // 基于程序顺序规则
        // 没有数据依赖关系，可以重排序下面代码 
        int i = 0;
        x = 2;
        // 基于volatile变量规则
        // 编译器插入storeload内存屏障指令 
        // 1）禁止代码和指令重排序
        // 2）强制刷新变量x的最新值到内存
    });
        
    Thread b = new Thread(() -> {
        int i = 0;
        // 存在数据依赖关系，无法重排序下面代码
        // 强制从主内存中读取变量x的最新值
        y = x;
        // 基于volatile变量规则
        // 编译器插入storeload内存屏障指令
        // 1）禁止代码和指令重排序
        // 2）强制刷新变量y的最新值到内存
        // 3）y = x；可能会被编译优化去除
        y = 3;
        // 编译器插入storeload内存屏障指令
        // 1）禁止代码和指令重排序
        // 2）强制刷新变量y的最新值到内存
    });
        
    Thread c = new Thread(() -> {
        // 基于程序顺序规则
        // 没有数据依赖关系，可以重排序下面代码
        int i = 0;
        // 基于volatile变量规则
        // 强制从主内存中读取变量x和y的最新值
        z = x * y;
        // 编译器插入storeload内存屏障指令
        // 1）禁止代码和指令重排序
        // 2）强制刷新变量z的最新值到内存
    });
        
    // ...start启动线程，join等待线程
    assert z == 6;
    // 可以看到a线程对变量x变更，b线程对变量y变更，最终对线程c可见
    // 即满足传递性规则
}

private int x, y, z;

public void test() {
    Thread a = new Thread(() -> {
       // synchronized，同步原语，程序逻辑将顺序串行执行
        synchronized (this){
            // 基于程序顺序规则
            // 没有数据依赖关系，可以重排序下面代码
            int i = 0;
            x = 2;
            // 基于监视器锁规则
            // 强制刷新变量x的最新值到内存
        }
    });
        
    Thread b = new Thread(() -> {
       // synchronized，同步原语，程序逻辑将顺序串行执行
        synchronized (this) {
            int i = 0;
            // 存在数据依赖关系，无法重排序下面代码
            // 强制从主内存中读取变量x的最新值
            y = x;
            // 基于监视器锁规则
            // 1）强制刷新变量y的最新值到内存
            // 2）y = x；可能会被编译优化去除
           y = 3;
            // 强制刷新变量y的最新值到内存
        }
    });
        
    Thread c = new Thread(() -> {
       // synchronized，同步原语，程序逻辑将顺序串行执行
        synchronized (this) {
            // 基于程序顺序规则
            // 没有数据依赖关系，可以重排序下面代码
            int i = 0;
            // 基于监视器锁规则
            // 强制从主内存中读取变量x和y的最新值
            z = x * y;
            // 强制刷新变量z的最新值到内存
        }
    });
        
    // ...start启动线程，join等待线程
    assert z == 6;
    // 可以看到a线程对变量x变更，b线程对变量y变更，最终对线程c可见
    // 即满足传递性规则
}

总结：在混沌与秩序间搭建桥梁

Java内存模型是并发编程中连接开发者与硬件系统的关键桥梁。它依托可见性、有序性和原子性这三大核心原则，将复杂的并发问题转化为清晰的编程规范。当多个线程操作共享变量时，Java内存模型利用volatile、synchronized等机制，有效抑制了处理器优化带来的不确定性，同时兼顾了性能优化需求。其定义的happens-before关系，如同线程间的通信准则，以顺序性规则替代了对缓存刷新、指令重排等底层操作的直接操控。这种设计让开发者能够专注于业务逻辑，仅凭有限的同步手段就能构建出稳健的多线程程序。

Java内存模型的价值在于达成了三个重要平衡：它确保程序正确性不依赖于硬件实现细节；维持同步规则的简洁性以控制复杂度；让开发者能以较低的认知成本构建并发系统。这无疑是工程解耦的典范：用简洁的抽象来掌控复杂的世界。

很高兴与你相遇！

如果你喜欢本文内容，记得关注哦！！！