Happens-before的作用是什么

发布时间：2021-06-23 11:04:26 作者：chen
来源：亿速云阅读：218

# Happens-before的作用是什么

## 摘要
本文深入探讨Java内存模型(JMM)中happens-before原则的核心作用，分析其在多线程编程中的关键保障，包括可见性保证、指令重排序约束和线程间操作顺序的确定性。通过具体代码示例、JMM规范解读以及与其他内存模型的对比，系统性地阐述happens-before如何构建可预测的并发编程模型。

## 目录
1. [引言](#引言)
2. [Java内存模型基础](#java内存模型基础)
3. [happens-before原则详解](#happens-before原则详解)
4. [happens-before的八大规则](#happens-before的八大规则)
5. [实际应用场景分析](#实际应用场景分析)
6. [与其他概念的对比](#与其他概念的对比)
7. [常见误区与验证方法](#常见误区与验证方法)
8. [总结](#总结)

---

## 引言
在多线程编程领域，"可见性"问题如同幽灵般困扰着开发者。当线程A修改了共享变量，线程B却可能看到过期的值，这种现象的根本原因在于现代计算机体系的多级缓存架构和编译器优化策略。Java通过JMM（Java Memory Model）中的happens-before原则，为开发者提供了一套强约束规则，使得在复杂的指令重排序和缓存同步机制下，仍然能够保证特定场景下的内存可见性和操作顺序。

> **典型案例**：在未正确同步的代码中，循环条件可能因可见性问题导致无限循环：
> ```java
> // 错误示例
> boolean running = true;
> 
> void threadA() {
>     while(running) { /*...*/ }  // 可能永远看不到false
> }
> 
> void threadB() {
>     running = false;
> }
> ```

## Java内存模型基础
### 2.1 内存模型必要性
现代硬件架构中存在的三大特性迫使需要内存模型：
- **写缓冲区**：处理器不会立即将写入提交到主存
- **指令重排序**：编译器/处理器为优化性能改变指令顺序
- **多级缓存**：CPU核心间缓存不一致

### 2.2 JMM抽象结构
Java内存模型通过抽象以下概念建立规范：

线程工作内存 <—> 主内存 ↑↓ 同步操作


### 2.3 重排序类型
| 重排序类型       | 说明                          |
|------------------|-----------------------------|
| 编译器优化重排序 | 在不改变单线程语义下的指令调整 |
| 指令级并行重排序 | CPU的流水线并行执行机制       |
| 内存系统重排序   | 缓存和写缓冲区造成的延迟      |

## happens-before原则详解
### 3.1 正式定义
若操作A happens-before操作B，则：
1. A对共享变量的修改对B可见
2. A的执行顺序在B之前

### 3.2 基本特性
- **传递性**：A hb B, B hb C ⇒ A hb C
- **非对称性**：A hb B ⇏ B hb A
- **非完全排序**：可能存在无hb关系的并发操作

### 3.3 与as-if-serial的关系
```mermaid
graph LR
    A[单线程as-if-serial] -->|保证| B[程序正确性]
    C[happens-before] -->|扩展| D[多线程可见性]

happens-before的八大规则

4.1 程序顺序规则

int x = 1;  // 1
int y = 2;  // 2 
// 1 hb 2

4.2 监视器锁规则

synchronized(lock) {
    x = 10;     // 1
}               // 1 hb 2（后续获取同一锁的操作）

4.3 volatile变量规则

volatile boolean flag = false;

// 线程A
flag = true;    // 1

// 线程B
if(flag) {      // 2
    // 1 hb 2
}

4.4 线程启动规则

Thread t = new Thread(() -> {
    // 子线程看到主线程的所有操作
});
x = 100;    // 1
t.start();  // 1 hb 子线程所有操作

4.5 线程终止规则

t.join();   // 1
// 线程t中的所有操作 hb 1之后的操作

4.6 中断规则

// 线程A
t.interrupt();  // 1

// 线程B
if(Thread.interrupted()) {  // 2
    // 1 hb 2
}

4.7 finalize规则

对象构造函数结束 hb finalize方法开始

4.8 传递性规则

// 线程A
synchronized(lock) { // 1
    x = 10;           // 2
}                     // 2 hb 3
// 线程B
synchronized(lock) { // 3
    print(x);        // 4
}

实际应用场景分析

5.1 单例模式实现

class Singleton {
    private static volatile Singleton instance;
    
    public static Singleton getInstance() {
        if(instance == null) {              // 第一次检查
            synchronized(Singleton.class) {
                if(instance == null) {      // 第二次检查
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

happens-before分析： 1. synchronized块内的写操作 hb 后续获取该锁的读操作 2. volatile写 hb 后续volatile读

5.2 并发计数器优化

class Counter {
    private long value;
    private volatile boolean flag;
    
    public void increment() {
        value++;                // 非原子操作
        flag = !flag;           // volatile写
    }
    
    public long get() {
        boolean f = flag;       // volatile读
        return value;          // 普通读
    }
}

5.3 线程间通信

// 生产者-消费者模式示例
class Message {
    private String content;
    private volatile boolean ready;
    
    public void send(String msg) {
        content = msg;          // 1
        ready = true;           // 1 hb 2
    }
    
    public String receive() {
        if(ready) {             // 2
            return content;     // 可见性保证
        }
        return null;
    }
}

与其他概念的对比

6.1 与synchronized比较

特性	happens-before	synchronized
作用范围	特定操作间	代码块范围
性能影响	细粒度控制	重量级操作
可见性保证	选择性保证	完全保证

6.2 与内存屏障关系

; x86架构内存屏障指令
LFENCE  ; 加载屏障
SFENCE  ; 存储屏障
MFENCE  ; 全屏障

Java中的实现映射： - volatile写 → StoreStore + StoreLoad - volatile读 → LoadLoad + LoadStore

6.3 与其他语言模型对比

语言	内存模型特性
C++11	更细粒度的memory_order
Go	happens-before通过channel
Rust	基于所有权模型的特殊规则

常见误区与验证方法

7.1 典型误解

“volatile变量所有操作都有happens-before”
错误：只有volatile写与后续读之间建立hb
“hb即时间先后”
错误：hb是可见性保证，不一定是时间顺序

7.2 验证技术

JCTools测试框架示例：

@JCStressTest
@Outcome(id = "1, 1", expect = ACCEPTABLE)
@State
public class HBVerification {
    int x;
    volatile int y;
    
    @Actor
    public void thread1() {
        x = 1;
        y = 1;
    }
    
    @Actor
    public void thread2(IntResult2 r) {
        r.r1 = y;
        r.r2 = x;
    }
}

7.3 调试技巧

使用-XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly查看汇编
JMM验证工具：Java Pathfinder (JPF)

总结

happens-before原则作为Java内存模型的基石，通过建立跨线程的操作顺序约束，解决了并发编程中的三大核心问题：

可见性：确保共享变量的修改能够及时传播
有序性：限制编译器和处理器的重排序自由度
可预测性：为开发者提供确定性的编程模型

掌握happens-before关系的本质，能够帮助开发者： - 正确理解现有并发工具的工作原理 - 设计出更高效的线程安全结构 - 快速诊断复杂的并发问题

“并发问题的复杂性不在于编写正确代码，而在于理解代码为什么正确。” —— Brian Goetz