volatile 深入：可见性、有序性与 happens-before

volatile write（写操作）：
  // 1. 将新值立即刷新到主内存
  // 2. 通过 MESI 协议通知其他 CPU 核心：这个缓存行无效

volatile read（读操作）：
  // 1. 使当前 CPU 缓存中该变量的缓存行失效
  // 2. 从主内存重新读取最新值

int a = 0, b = 0;
int x = 0, y = 0;

// 线程 1
a = 1;      // ①
x = b;      // ②

// 线程 2
b = 1;      // ③
y = a;      // ④

// 正常思维：x=0,y=0 或 x=1,y=1 或 x=1,y=0
// 但 ① ② 重排后变成 ② ① → 可能出现 x=0, y=0 且 a=1, b=1 的诡异结果

public class VolatileAtomicTest {
    static volatile int count = 0;

    public static void main(String[] args) throws Exception {
        CountDownLatch latch = new CountDownLatch(100);
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    count++; // 看似简单的自增
                }
                latch.countDown();
            }).start();
        }
        latch.await();
        System.out.println("count = " + count);
        // 期望：100000，实际：往往 < 100000
    }
}

// 第 1 步：read —— 从内存读取 count 的值
int temp = count;       // 比如读到 42

// 第 2 步：modify —— 在寄存器中加 1
temp = temp + 1;          // 变成 43

// 第 3 步：write —— 把新值写回内存
count = temp;            // 写入 43

public 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;
    }
}

new        // ① 分配内存空间
dup
invokespecial // ② 调用构造方法初始化对象
putstatic   // ③ 把引用赋值给 instance 变量

// 线程 A 执行 getInstance()
T1: 分配内存
T2: instance = 引用          // 引用不为 null 了！但对象还没初始化

// 线程 B 执行 getInstance()
T3: if (instance == null)   // false！跳过 synchronized 块
T4: return instance          // 返回了一个半初始化的对象 → NPE 或逻辑错误

// 线程 A 继续
T5: 初始化对象               // 但线程 B 已经拿到了未初始化的引用

volatile boolean running = true;

// 工作线程
while (running) {
    // 干活...
}

// 管理线程
running = false; // 工作线程下次循环时一定能看到 false

volatile Config config;

// 初始化线程
Config c = new Config(loadFromFile()); // 构造完成
config = c;  // volatile write：保证其他线程看到 config != null 时，Config 内部字段也已初始化

// 其他线程
if (config != null) {
    config.getPort(); // 一定能读到正确的值
}

// 见第 6 站，volatile 防止指令重排导致半初始化对象

// volatile：只保证可见性和有序性，适合简单的读写
volatile int flag = 0;
flag = 1;              // ✅ 单次写，安全
int x = flag;          // ✅ 单次读，安全
flag++;                // ❌ 读-改-写，不安全

// AtomicInteger：基于 CAS，保证原子性 + 可见性
AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet(); // ✅ CAS 循环，原子操作
count.compareAndSet(0, 1); // ✅ CAS，原子操作

"volatile 保证可见性和有序性，不保证原子性。

 可见性：volatile write 会立即刷回主内存，并让其他核心的缓存行失效；
         volatile read 会使本地缓存失效，从主内存重新加载。

 有序性：通过在操作前后插入内存屏障，阻止编译器和 CPU 对屏障两侧的指令重排。
         例如 DCL 单例中，volatile 阻止了对象创建时 '赋值引用' 和 '初始化' 的重排。

 不保证原子性：count++ 是读-改-写三步操作，volatile 只保证读到的值是最新的，
              但三步之间可能被其他线程干扰，导致更新丢失。应该用 AtomicInteger。"