Happens-Before原则详解

Happens-Before是什么

在Java内存模型(JMM)中,Happens-Before原则是用于描述多线程程序中操作执行顺序的重要规则。它是理解线程间内存可见性和有序性的关键。

核心定义: 如果一个操作A "happens-before" 另一个操作B,那么操作A的执行结果对操作B是可见的。

我们知道,在单线程环境中有as-if-serial语义保证程序执行结果的正确性。而在多线程环境下,happens-before原则就扮演了类似的角色,用于保证跨线程的内存可见性和有序性。

一个典型例子

看下面这段代码:

public class DataInitializer {
    private int dataValue = 100;

    public void initializeData() {
        dataValue += 50;  // 主线程修改
        new Thread(() -> {
            int localData = dataValue;  // 子线程读取
            System.out.println("读取到的值: " + localData);
        }).start();
    }
}

这段代码中,主线程修改了 dataValue,子线程读取 dataValue,但我们并没有使用 synchronized 加锁,也没有用 volatile 修饰变量。那么JVM是如何保证主线程的修改对子线程可见的呢?

答案就是happens-before原则中的"线程启动规则"在发挥作用。

Happens-Before的八大规则

happens-before原则并不是在任何场景都适用,它有一些明确的规则。只有在满足这些规则的情况下,才能保证操作间的happens-before关系。

程序次序规则

规则: 在单个线程内,按照程序代码顺序,前面的操作happens-before后面的操作。

public class ProgramOrderDemo {
    private int x = 0;
    private int y = 0;

    public void executeInOrder() {
        x = 10;  // 操作1
        y = 20;  // 操作2
        int z = x + y;  // 操作3
        // 操作1 happens-before 操作2
        // 操作2 happens-before 操作3
    }
}

这个规则保证了在单线程内,代码的逻辑顺序得到维护,即使底层可能发生指令重排,但重排不会影响最终结果。

管程锁定规则

规则: 对一个锁的解锁操作happens-before后续对这个锁的加锁操作。

public class MonitorLockDemo {
    private int counter = 0;
    private final Object lockObject = new Object();

    public void incrementCounter() {
        synchronized(lockObject) {
            counter++;  // 操作在锁内执行
        }  // 释放锁
    }

    public int readCounter() {
        synchronized(lockObject) {  // 获取锁
            return counter;  
            // increment中的counter++
            // happens-before 这里的读取操作
        }
    }
}

这个规则确保了synchronized代码块内的修改,在下一个获取同一把锁的线程中是可见的。

Volatile变量规则

规则: 对volatile字段的写操作happens-before任意后续对这个字段的读操作。

public class VolatileDemo {
    private volatile boolean ready = false;
    private int result = 0;

    public void prepareData() {
        result = 100;  // 操作1
        ready = true;  // volatile写操作
    }

    public void useData() {
        if (ready) {  // volatile读操作
            // 此时能看到result=100
            // 因为volatile写 happens-before volatile读
            System.out.println("结果: " + result);
        }
    }
}

volatile保证了写操作对后续读操作立即可见,这是实现线程间通信的重要手段。

线程启动规则

规则: 对线程的 start() 方法调用happens-before该线程的每个操作。

public class ThreadStartDemo {
    private int initialValue = 100;

    public void launchThread() {
        initialValue += 50;  // 主线程修改
        
        Thread worker = new Thread(() -> {
            // 这里能看到initialValue=150
            // 因为start()之前的操作 happens-before 线程内的操作
            int local = initialValue;
            System.out.println("工作线程读取: " + local);
        });
        
        worker.start();
    }
}

这个规则确保了在启动新线程之前,主线程对共享变量的所有修改对新线程都是可见的。

线程终止规则

规则: 线程的所有操作happens-before对这个线程的 join() 方法成功返回。

public class ThreadJoinDemo {
    private int taskResult = 0;

    public void executeTask() throws InterruptedException {
        Thread worker = new Thread(() -> {
            // 执行计算任务
            for (int i = 1; i <= 100; i++) {
                taskResult += i;
            }
        });
        
        worker.start();
        worker.join();  
        
        // join()返回后,能看到worker线程的所有修改
        // 因为worker的操作 happens-before join()的返回
        System.out.println("任务结果: " + taskResult);
    }
}

线程中断规则

规则: 对线程 interrupt() 方法的调用happens-before被中断线程检测到中断事件的发生。

这个规则保证了线程中断操作的可见性,确保被中断的线程能够及时检测到中断状态。

对象终结规则

规则: 对象的初始化完成(构造函数执行结束)happens-before它的 finalize() 方法的开始。

public class FinalizerDemo {
    private int data;

    public FinalizerDemo(int value) {
        this.data = value;  // 构造函数中初始化
    }

    @Override
    protected void finalize() throws Throwable {
        // finalize执行时,构造函数一定已经执行完成
        // 所以这里data一定是已初始化的值
        System.out.println("清理对象,data=" + data);
        super.finalize();
    }
}

这个规则确保了对象在被回收前,其初始化过程已经完全结束。

传递性规则

规则: 如果操作A happens-before 操作B,操作B happens-before 操作C,那么操作A happens-before 操作C。

public class TransitivityDemo {
    private volatile boolean initialized;
    private int configValue;

    public void initConfig() {
        configValue = 200;    // 操作A
        initialized = true;   // 操作B (volatile写)
    }

    public void useConfig() {
        if (initialized) {    // 操作C (volatile读)
            // 根据传递性:
            // A happens-before B (程序次序规则)
            // B happens-before C (volatile规则)
            // 因此 A happens-before C
            // 所以这里能看到configValue=200
            System.out.println("配置值: " + configValue);
        }
    }
}

传递性规则非常重要,它让我们可以通过组合不同的happens-before规则来建立更复杂的可见性保证。

Happens-Before与As-If-Serial的关系

虽然happens-before和as-if-serial都与程序执行的顺序性和一致性有关,但它们的关注点不同:

As-If-Serial语义

适用范围: 单线程环境
核心思想: 不管怎么重排序,单线程程序的执行结果不能改变
作用: 允许编译器和处理器优化,但保证单线程程序的正确性
关注点: 单线程内的执行结果一致性