Java 内存模型（JMM）与 happens-before 详解 ⭐⭐⭐

// Java 代码
int x = 10;  // 线程对变量的写操作

// 实际在 JMM 中的执行流程（简化版）：
// 1. assign：线程在工作内存中给变量 x 赋值 10
// 2. store：将 x = 10 从工作内存写入主内存
// 3. write：将主内存中的 x 值标记为已更新

// 其他线程读取 x 的流程：
// 1. read：从主内存读取最新的 x 值
// 2. load：将 x 值加载到工作内存
// 3. use：线程使用工作内存中的 x 值

public class VisibilityProblem {
    private boolean flag = false;

    // 线程 A：写入者
    public void writer() {
        flag = true;  // 修改 flag
        System.out.println("Writer finished");
    }

    // 线程 B：读取者
    public void reader() {
        while (!flag) {  // 一直循环
            // 线程 B 可能永远看不到 flag = true
        }
        System.out.println("Reader sees flag = true");
    }
}

// 线程 A
x = 1;          // Store 1
flag = true;   // Store 2

// 线程 B
if (flag) {    // Load flag
    System.out.println(x);  // Load x
}

public class BusyLoop {
    private static boolean done = false;

    public static void main(String[] args) throws InterruptedException {
        // 线程 1：修改 done
        new Thread(() -> {
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            done = true;
        }).start();

        // 线程 2：等待 done
        while (!done) {
            // 理论上应该退出，但可能永远循环！
        }
        System.out.println("Done!");
    }
}

public class ObjectEscape {
    private int value = 0;
    private static ObjectEscape instance;

    public static void create() {
        instance = new ObjectEscape();  // 逸出！
        instance.value = 42;
    }
}
// 如果指令重排序，可能导致其他线程看到 value = 0 的半初始化对象

public class DCL {
    private static DCL instance;

    public static DCL getInstance() {
        if (instance == null) {          // 线程 B 可能跳过此处
            synchronized (DCL.class) {
                if (instance == null) {
                    instance = new DCL(); // 可能返回未初始化完成的对象
                }
            }
        }
        return instance;
    }
}

// 原子操作
x = 1;           // 基本类型赋值
y = obj.field;   // 引用赋值

// 非原子操作
x++;             // 实际是：read → increment → write
obj.field = 1;   // 如果 obj 引用发生改变，不安全
i = i + 1;       // 复合操作

public class LongDoubleDemo {
    // 在 32 位 JVM 中，下面的操作可能非原子：
    private long value;    // 可能读到高 32 位和低 32 位不一致的值
    private double d;      // 同理

    // 解决方案 1：加 synchronized
    private synchronized void setValue(long v) { value = v; }
    private synchronized long getValue() { return value; }

    // 解决方案 2：使用 volatile（Java 1.5+ 保证原子性）
    private volatile long value2;
}

int a = 0;
boolean flag = false;

// 线程 A
a = 1;         // 操作 1
flag = true;   // 操作 2

// 线程 B
if (flag) {    // 操作 3
    // 这里一定能读到 a = 1 吗？
    System.out.println(a);  // 操作 4
}

// 线程 A 可能被重排为：
flag = true;   // 先执行
a = 1;         // 后执行

// 线程 B 执行时：
// flag = true → 进入 if → a 可能还是 0！（没来得及被 A 赋值）

int a = 1;      // 1. happens-before 2.
int b = 2;      // 2. happens-before 3.
int c = a + b;  // 3.

Thread A:
x = 1;          // ① happens-before ②
y = 2;          // ② happens-before ③
z = x + y;      // ③

// 注意：这里说的是单个线程内的有序性
// 编译器/CPU 可以重排 ① ② ③，只要重排后结果一致

synchronized (lock) {
    // 临界区代码
    x = 100;    // 线程 A 在临界区内修改
}               // unlock

// ... 其他线程 ...

synchronized (lock) {
    // 线程 B 进入临界区
    int val = x;  // 一定能读到线程 A 修改后的值 100
}

// 线程 A
lock.lock();         // 获取锁
x = 100;              // 修改共享变量
lock.unlock();        // 释放锁  happens-before

// 线程 B
lock.lock();          // 获取锁  happens-before
int val = x;          // 一定能看到 x = 100
lock.unlock();

volatile int x = 0;

// 线程 A
x = 1;           // 写 volatile

// 线程 B
int y = x;       // 读 volatile

// 线程 B 一定能看到 x = 1
// 线程 A 在写 x 之前的所有操作对线程 B 都可见

Thread B = new Thread(() -> {
    // 这里能读到 done = false 吗？
    while (!done) { }
    System.out.println("Done!");
});

done = true;         // 线程 A
B.start();           // happens-before

// 线程 B 启动后，一定能看到 done = true

Thread B = new Thread(() -> {
    x = 100;
    y = 200;
});

B.start();
B.join();  // 等待 B 终止

// 在主线程中：
// B 线程的所有操作对主线程可见
// 一定能读到 x = 100, y = 200

// 线程 A（主线程）
B.start();          // 启动线程 B

// ... 其他代码 ...

B.join();          // 等待 B 终止
// 此时，B 线程的所有操作已完成
// B 线程对 x, y 的修改对主线程可见
System.out.println(x);  // 输出 100
System.out.println(y);  // 输出 200

Thread B = new Thread(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        // 业务逻辑
    }
});

B.interrupt();  // 主线程调用

// B 线程中，isInterrupted() 返回 true
// 或抛出 InterruptedException

public class MyObject {
    private int value = 10;  // 在构造方法中赋值

    @Override
    protected void finalize() throws Throwable {
        // 这里一定能读到 value = 10
        System.out.println(value);
    }
}

// 原因：构造函数结束 happens-before finalize() 开始
// 但注意：finalize() 的执行时机不确定，只是保证可见性

// 示例
int a = 1;           // 1. happens-before 2.
volatile int b = 2;  // 2. happens-before 3.
int c = a + b;       // 3.

// 传递性：1. happens-before 3.
// 所以 c 一定能读到 a = 1, b = 2

public class HBExample {
    private int x = 0;
    private volatile boolean flag = false;

    public void write() {
        x = 42;           // 1.
        flag = true;      // 2. volatile 写
    }

    public void read() {
        if (flag) {       // 3. volatile 读
            // 根据 volatile 规则：2. happens-before 3.
            // 根据程序顺序规则：1. happens-before 2.
            // 根据传递性：1. happens-before 3.
            // 所以这里一定能看到 x = 42
            System.out.println(x);  // 输出 42
        }
    }
}

volatile int x = 0;

// 线程 A 写 x = 1：
// 1. StoreStore 屏障（确保之前的普通写都已刷新到主内存）
// 2. volatile 写（x = 1，写入主内存，同时 invalid 其他 CPU 缓存）
// 3. StoreLoad 屏障（确保写对后续的读可见）
// 底层：Lock 前缀指令（x86）或 DMB（ARM）

// 线程 B 读 x：
// 1. LoadLoad 屏障（确保后续普通读不会先执行）
// 2. LoadStore 屏障（确保不会和后续写重排）
// 3. volatile 读（从主内存读取最新值）
// 底层：内存屏障指令或缓存一致性协议保证

public class ReorderDemo {
    private int a = 0;
    private int b = 0;
    private int x = 0;
    private int y = 0;

    // 线程 A
    public void threadA() {
        a = 1;          // S1
        x = b;          // S2
    }

    // 线程 B
    public void threadB() {
        b = 1;          // S3
        y = a;          // S4
    }
}

volatile int balance = 1000;

// 线程 A（生产者）：
balance = 2000;           // volatile 写
// 语义：
// 1. 将本地内存中的值刷新到主内存
// 2. 使其他 CPU 缓存中的副本失效
// 3. happens-before 所有后续的 volatile 读

// 线程 B（消费者）：
int current = balance;    // volatile 读
// 语义：
// 1. 使 CPU 缓存失效，从主内存重新读取
// 2. happens-before 所有后续的操作

public class Singleton {
    private static volatile Singleton instance;  // 关键！

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                    // 构造过程（简化）：
                    // 1. 分配内存
                    // 2. 调用构造方法
                    // 3. instance = 引用赋值
                    // volatile 禁止了 2 和 3 的重排序
                }
            }
        }
        return instance;
    }
}

volatile int[] arr = new int[10];

// arr 是 volatile，但 arr[0] 不是！
// volatile 保证的是 arr 引用本身可见
// arr[i] 的访问需要额外同步

arr = new int[20];  // 整个数组引用可见

// 如果要 volatile 数组语义，需要：
volatile int[] arr2;
public synchronized void write() {
    arr2[0] = 1;  // 同步保证可见性
}

synchronized (obj) {
    x = 100;
}

// 编译后生成字节码：
// monitorenter    // 获取锁
// x = 100;
// monitorexit     // 释放锁

// 底层实现：
// 1. Mark Word 中的锁状态改变
// 2. 轻量级锁：CAS 修改栈帧中的锁记录
// 3. 重量级锁：OS mutex，挂起线程

public class FinalFieldDemo {
    final int x;           // final 域
    int y;                 // 普通域
    static FinalFieldDemo instance;

    public FinalFieldDemo() {
        x = 1;             // 1. 写入 final 域
        y = 2;             // 2. 写入普通域
    }

    public static void writer() {
        instance = new FinalFieldDemo();  // 构造 + 引用赋值
    }

    public static void reader() {
        FinalFieldDemo obj = instance;     // 读取引用
        // 此时 obj.x 一定等于 1（final 保证）
        // 但 obj.y 可能等于 0（未正确构造风险）
    }
}

public class EscapeDemo {
    final int value;
    static EscapeDemo instance;

    // 错误写法：在构造方法中逸出 this
    public EscapeDemo() {
        value = 100;
        instance = this;  // 逸出！其他线程可能看到未构造完成的对象
    }
}

// 正确写法：
public class SafeDemo {
    final int value;

    public SafeDemo(int v) {
        value = v;  // 先初始化所有域
        // 不要在构造方法中逸出 this
    }
}

// 不可变对象天然线程安全
public final class ImmutablePerson {
    private final String name;    // final
    private final int age;        // final

    public ImmutablePerson(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 没有 setter，所有字段 final
    // 每次返回新的实例
}

// 使用：无需同步，可共享
ImmutablePerson p = new ImmutablePerson("Alice", 30);