JMM 内存模型：happens-before 八条规则全解

class VisibilityDemo {
    static boolean flag = false;
    static int number = 0;

    // Thread-1
    static void writer() {
        number = 42;    // 写入
        flag = true;    // 标志位
    }

    // Thread-2
    static void reader() {
        if (flag) {              // 看到了 flag=true
            System.out.println(number);  // 但 number 可能还是 0！
        }
    }
}

// 主内存操作：
lock      → 锁定主内存中的变量（标识为线程独占）
unlock    → 解锁主内存中的变量
read      → 从主内存读取变量值（传输到工作内存）
write     → 将工作内存的值写入主内存

// 工作内存操作：
load      → 将 read 得到的值放入工作内存副本
store     → 将工作内存的值传送到主内存（配合 write）
use       → 将工作内存的值传递给执行引擎
assign    → 将执行引擎的值赋给工作内存变量

class Counter {
    static int count = 0;
    // i++ 实际是三步：read → increment → write
    static void increment() { count++; }

    public static void main(String[] args) throws Exception {
        Thread[] threads = new Thread[100];
        for (int i = 0; i < 100; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) increment();
            });
            threads[i].start();
        }
        for (Thread t : threads) t.join();
        System.out.println(count);  // 期望 100000，实际 < 100000
    }
}

class ReorderDemo {
    static int a = 0, b = 0;
    static int x = 0, y = 0;

    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(() -> { a = 1; x = b; });  // 可能被重排为 x=b; a=1;
        Thread t2 = new Thread(() -> { b = 1; y = a; });  // 可能被重排为 y=a; b=1;
        t1.start(); t2.start(); t1.join(); t2.join();
        // 理论上 x=0, y=0 是可能出现的！
    }
}

int a = 1;   // A
int b = 2;   // B
// 在单线程中：A happens-before B
// 编译器/CPU 可以重排序，但必须保证单线程结果一致（as-if-serial）

class SyncExample {
    int value = 0;
    synchronized void set(int v) { value = v; }   // unlock happens-before...
    synchronized int get() { return value; }       // ...后续 lock
}
// Thread-1 调用 set(42) → unlock
// Thread-2 调用 get()  → lock → 一定看到 42

volatile boolean ready = false;
int data = 0;

// Thread-1
data = 42;          // A
ready = true;       // B (volatile write)

// Thread-2
if (ready) {        // C (volatile read) → B happens-before C
    print(data);    // 一定看到 42（A→B→C 传递性）
}

int config = loadConfig();
Thread worker = new Thread(() -> {
    // 这里一定能看到 config 的值
    // start() happens-before 此线程中的任何操作
    process(config);
});
worker.start();  // 这个调用 happens-before worker 线程内的所有代码

Thread worker = new Thread(() -> {
    result = compute();  // 计算结果
});
worker.start();
worker.join();          // join 返回后
print(result);          // 一定能看到 worker 线程中写入的 result

Thread t = new Thread(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        // 当 interrupt() 被调用，isInterrupted() 一定返回 true
        // interrupt() happens-before isInterrupted() 检测到中断
    }
});
t.start();
t.interrupt();  // 中断信号一定对目标线程可见

class Resource {
    FileInputStream stream;
    Resource() { stream = new FileInputStream("data.bin"); }  // 构造
    protected void finalize() {
        // 一定能看到构造函数中初始化的 stream
        // 构造 happens-before finalize
        stream.close();
    }
}
// 注：Java 9+ 已弃用 finalize，推荐 Cleaner / try-with-resources

// 这是 happens-before 关系最重要的性质
// volatile 的经典用法就是利用传递性：
int a = 1;            // A
int b = 2;            // B
volatile boolean flag = true;  // C（volatile write）

// A → B → C (程序顺序) → volatile read → 后续操作
// 传递性保证：读到 flag=true 的线程，一定能看到 a=1, b=2

class Singleton {
    private static volatile Singleton instance;  // 必须 volatile！

    public static Singleton getInstance() {
        if (instance == null) {                  // 第一次检查（无锁）
            synchronized (Singleton.class) {
                if (instance == null) {              // 第二次检查（有锁）
                    instance = new Singleton();     // 问题在这里！
                }
            }
        }
        return instance;
    }
}

class LazyInit {
    static Resource resource;

    static Resource get() {
        if (resource == null) {
            resource = new Resource();  // 非 volatile，可能拿到半初始化对象
        }
        return resource;
    }
}
// 解决方案：用 volatile，或用 Holder 内部类（静态内部类延迟加载）

// 面试官问："请解释一下 Java 的内存模型"
// 先确认他问的是哪个：

// 如果问的是 JMM（JSR-133）：
// → 聊 happens-before、volatile、可见性

// 如果问的是 JVM 运行时数据区：
// → 聊堆（新生代/老年代）、栈、方法区/元空间

// 如果不确定，可以主动区分：
// "Java 内存模型有两个层面，一个是 JSR-133 定义的
//  线程间可见性模型，另一个是 JVM 的运行时数据区划分，
//  您想了解哪方面？"