volatile深度解析 ⭐⭐⭐

public class VolatileSyntaxDemo {
 
    // ✅ 修饰实例变量 —— 最常见的用法
    private volatile boolean running = true;
 
    // ✅ 修饰静态变量 —— 同样合法
    private static volatile int globalCounter = 0;
 
    // ✅ 修饰引用类型 —— 注意：只保证引用本身的可见性，不保证对象内部字段的可见性
    private volatile List<String> dataList = new ArrayList<>();
 
    // ✅ 修饰数组引用 —— 同理：只保证数组引用可见，不保证数组元素可见
    private volatile int[] dataArray = new int[10];
 
    // ❌ 编译错误：volatile 不能修饰局部变量
    // public void method() {
    //     volatile int localVar = 0;  // 编译不通过
    // }
 
    // ❌ 编译错误：volatile 不能修饰方法
    // public volatile void doSomething() { }
 
    // ❌ 编译错误：volatile 不能修饰类
    // public volatile class MyClass { }
}

public class VolatileModifierCombination {
 
    // ✅ private + volatile：最常见的组合，封装 + 可见性
    private volatile boolean shutdownRequested = false;
 
    // ✅ protected + volatile：子类可访问的可见性字段
    protected volatile int state = 0;
 
    // ✅ public + volatile：公开的可见性字段（不推荐，破坏封装）
    public volatile long timestamp = 0L;
 
    // ✅ static + volatile：类级别的可见性字段
    private static volatile VolatileModifierCombination instance;
 
    // ✅ volatile + transient：可见性 + 序列化排除
    private volatile transient boolean connected = false;
 
    // ❌ volatile + final：编译错误！语义矛盾
    // final 表示不可变，volatile 修饰一个不可变的值毫无意义
    // private volatile final int MAX = 100;  // 编译不通过
}

public class VolatileDataTypes {
 
    // ===== 基本类型（Primitive Types）=====
    // 对于基本类型，volatile 保证读写操作的可见性
    private volatile boolean flag;       // 1 bit 逻辑值
    private volatile byte b;             // 8 bits
    private volatile short s;            // 16 bits
    private volatile int i;              // 32 bits
    private volatile long l;             // 64 bits ⭐ 特别重要
    private volatile float f;            // 32 bits
    private volatile double d;           // 64 bits ⭐ 特别重要
    private volatile char c;             // 16 bits
 
    // ===== 引用类型（Reference Types）=====
    // volatile 只保证「引用地址」的可见性，不保证「引用对象内部状态」的可见性
    private volatile String name;                    // 不可变对象引用，安全
    private volatile Map<String, Object> configMap;  // 可变对象引用，需要小心
    private volatile int[] numbers;                  // 数组引用，元素不受保护
}

public class VolatileReferenceTrap {
 
    // volatile 修饰的是 config 这个「引用」
    // 而不是 Config 对象内部的 url 和 timeout 字段
    private volatile Config config = new Config();
 
    static class Config {
        String url = "http://default";    // 非 volatile，不受保护
        int timeout = 3000;               // 非 volatile，不受保护
    }
 
    // ===== 线程 A：修改对象内部字段 =====
    public void writerThread() {
        // ❌ 危险操作！修改的是对象内部字段，不是引用本身
        // volatile 语义不会被触发，其他线程可能看不到这些修改
        config.url = "http://new-server";
        config.timeout = 5000;
    }
 
    // ===== 正确做法：替换整个引用 =====
    public void writerThreadCorrect() {
        // ✅ 创建新的 Config 对象
        Config newConfig = new Config();       // 在本地构建新对象
        newConfig.url = "http://new-server";   // 设置新值
        newConfig.timeout = 5000;              // 设置新值
        config = newConfig;                    // 替换引用 → 触发 volatile 写语义
        // 此时其他线程读取 config 引用时，
        // 能看到新的 Config 对象及其字段（happen-before 保证）
    }
 
    // ===== 线程 B：读取配置 =====
    public void readerThread() {
        Config snapshot = config;    // volatile 读 → 获取最新引用
        // 由于 happen-before 关系，通过新引用能安全读取其字段
        System.out.println(snapshot.url + ", timeout=" + snapshot.timeout);
    }
}

public class VolatileArrayDemo {
 
    // volatile 只保护 data 这个引用，不保护 data[0], data[1] ...
    private volatile int[] data = new int[5];
 
    public void unsafeElementWrite() {
        // ❌ 修改数组元素不会触发 volatile 语义
        data[0] = 42;   // 其他线程可能看不到
    }
 
    public void safeArrayReplace() {
        // ✅ 替换整个数组引用会触发 volatile 语义
        int[] newData = new int[5];   // 创建新数组
        newData[0] = 42;              // 在本地修改
        data = newData;               // volatile 写，发布新数组
    }
 
    // 如果需要对数组元素做原子可见性操作，应使用：
    // java.util.concurrent.atomic.AtomicIntegerArray
    // java.util.concurrent.atomic.AtomicReferenceArray
}

程序员说："这个变量会被多个线程同时读写。"
JVM 回应："好的，我保证：
           1. 每次读取都从主内存获取最新值（可见性）
           2. 每次写入立即刷回主内存（可见性）
           3. 不对这个变量相关的操作做重排序（有序性）
           4. 对于 long/double，保证原子性读写
         但我不保证：
           ⚠️ 复合操作（如 i++）的原子性"

public class VolatileBasicExample {
 
    // 使用 volatile 修饰停止标志
    // 如果不加 volatile，子线程可能永远看不到 main 线程的修改
    private static volatile boolean stop = false;
 
    public static void main(String[] args) throws InterruptedException {
 
        // 启动一个工作线程，不断循环检测 stop 标志
        Thread worker = new Thread(() -> {
            int count = 0;                         // 本地计数器
            while (!stop) {                        // 每次循环都读取 volatile 变量
                count++;                           // 做一些工作
            }
            // stop 变为 true 时退出循环
            System.out.println("Worker stopped after " + count + " iterations.");
        }, "worker-thread");
 
        worker.start();                            // 启动工作线程
 
        Thread.sleep(100);                         // 主线程等待 100ms
 
        stop = true;                               // volatile 写：立即对 worker 线程可见
        System.out.println("Main thread set stop = true");
 
        worker.join();                             // 等待 worker 线程结束
        System.out.println("Program finished.");
    }
}

/**
 * 可见性问题经典演示
 * 线程 reader 可能永远看不到 writer 对 flag 的修改
 */
public class VisibilityProblem {
 
    // 注意：这里故意没有加 volatile
    private static boolean flag = false;       // 共享的停止标志
    private static int number = 0;             // 共享的数值变量
 
    public static void main(String[] args) throws InterruptedException {
 
        // reader 线程：持续检查 flag 是否变为 true
        Thread reader = new Thread(() -> {
            while (!flag) {                    // 可能读取的是工作内存中的旧值 false
                // 空循环，等待 flag 变为 true
            }
            // 如果能走到这里，打印 number 的值
            System.out.println("number = " + number);
        });
 
        // writer 线程：修改共享变量
        Thread writer = new Thread(() -> {
            number = 42;                       // 先写 number
            flag = true;                       // 再写 flag，期望 reader 看到后退出循环
        });
 
        reader.start();                        // 先启动 reader
        Thread.sleep(100);                     // 让 reader 充分运行，进入循环
        writer.start();                        // 再启动 writer
 
        reader.join(3000);              // 最多等 3 秒
        writer.join(3000);
 
        // 在某些 JVM/CPU 组合下，reader 线程会卡死在 while 循环中
        System.out.println("Main thread finished.");
    }
}

/**
 * volatile 写操作的语义演示
 * writer 线程对 volatile 变量的赋值会立即刷入主内存
 */
public class VolatileWriteDemo {
 
    // 使用 volatile 修饰，写操作将强制刷新主内存
    private static volatile boolean flag = false;
 
    public static void main(String[] args) throws InterruptedException {
 
        Thread writer = new Thread(() -> {
            System.out.println("Writer: 准备将 flag 设为 true...");
            // 这条赋值语句在 JMM 层面会触发以下操作序列：
            // 1. assign: 将 true 赋给工作内存中的 flag 副本
            // 2. store:  将工作内存中的 flag 新值传送到主内存
            // 3. write:  将传送过来的值写入主内存的 flag 变量
            // 以上三步对 volatile 变量来说是「原子性地连续执行」的
            flag = true;
            System.out.println("Writer: flag 已写入主内存 = " + flag);
        });
 
        writer.start();
        writer.join();
 
        // 此时主内存中的 flag 已经确定是 true
        System.out.println("Main: 从主内存读取 flag = " + flag);
    }
}

/**
 * volatile 读操作的语义演示
 * reader 线程每次访问 volatile 变量都从主内存拉取最新值
 */
public class VolatileReadDemo {
 
    // volatile 修饰，确保每次读取都穿透到主内存
    private static volatile int sharedValue = 0;
 
    public static void main(String[] args) throws InterruptedException {
 
        // reader 线程：每隔一段时间读取 sharedValue
        Thread reader = new Thread(() -> {
            int localCopy;                          // 线程栈上的局部变量
            while (true) {
                // 对 volatile 变量的读取操作，JMM 保证：
                // 1. read:  从主内存中读取 sharedValue 的最新值
                // 2. load:  将读到的值载入工作内存
                // 3. use:   将工作内存中的值交给执行引擎使用
                localCopy = sharedValue;            // 每次都拿到最新值
                if (localCopy != 0) {               // 检测到变化
                    System.out.println("Reader 发现: sharedValue = " + localCopy);
                    break;                          // 退出循环
                }
            }
        });
 
        // writer 线程：延迟 1 秒后修改 sharedValue
        Thread writer = new Thread(() -> {
            try {
                Thread.sleep(1000);                 // 让 reader 先跑一会儿
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println("Writer: 将 sharedValue 设为 99");
            sharedValue = 99;                       // volatile 写，立即刷入主内存
        });
 
        reader.start();
        writer.start();
        reader.join();
        writer.join();
        // 输出: Reader 发现: sharedValue = 99
    }
}

/**
 * 使用 volatile 修复可见性问题
 */
public class VisibilityFixed {
 
    // 加上 volatile 修饰 —— 可见性得到保障
    private static volatile boolean flag = false;
    private static volatile int number = 0;        // 这里也加上，保证 number 的可见性
 
    public static void main(String[] args) throws InterruptedException {
 
        Thread reader = new Thread(() -> {
            // volatile 读：每次循环都从主内存拉取 flag 最新值
            while (!flag) {
                // 不会被 JIT 优化为 "读寄存器中的旧值"
                // 因为 volatile 禁止了这种提升优化 (hoisting)
            }
            // 当 flag 为 true 时，能保证看到 number = 42
            // 这是 volatile 的 happens-before 传递性在起作用
            System.out.println("number = " + number);  // 输出: number = 42
        });
 
        Thread writer = new Thread(() -> {
            number = 42;                               // volatile 写
            flag = true;                               // volatile 写，立即刷入主内存
        });
 
        reader.start();
        Thread.sleep(100);
        writer.start();
 
        reader.join(3000);
        writer.join(3000);
    }
}

/**
 * JIT 优化对比演示
 * 展示 volatile 如何阻止 JIT 编译器的寄存器提升优化
 */
public class JitOptimizationDemo {
 
    // 场景 1：普通变量 —— JIT 可能将 running 提升到寄存器
    private static boolean running = true;
 
    // 场景 2：volatile 变量 —— JIT 被强制禁止缓存优化
    // private static volatile boolean running = true;
 
    public static void main(String[] args) throws InterruptedException {
 
        Thread worker = new Thread(() -> {
            int count = 0;
            // JIT 编译后，这里的 running 可能被提升为寄存器值
            // 优化后的伪代码大致为：
            //   bool r = running;     // 只读取一次
            //   while (r) {           // 永远用寄存器中的值
            //       count++;
            //   }
            // 因此即使主线程修改了 running，worker 也看不到
            while (running) {
                count++;               // 不断累加
            }
            System.out.println("Worker 退出, count = " + count);
        });
 
        worker.start();
        Thread.sleep(2000);            // 让 worker 运行 2 秒，触发 JIT 编译
        System.out.println("Main: 设置 running = false");
        running = false;               // 普通写，不保证 worker 能看到
        worker.join(3000);             // 等待 worker，可能超时（worker 卡死）
 
        if (worker.isAlive()) {
            System.out.println("Worker 线程未能退出！可见性问题发生！");
            // 在 Server 模式 JVM (-server) 下大概率出现
        }
    }
}

int x = 0;                  // 普通变量
volatile boolean flag = false;  // volatile 变量
 
// 线程 A 执行
void writer() {
    x = 42;                 // 语句 1
    flag = true;            // 语句 2 (volatile 写)
}
 
// 线程 B 执行
void reader() {
    if (flag) {             // 语句 3 (volatile 读)
        int result = x;     // 语句 4
        System.out.println(result);
    }
}

// ============================================================
// 指令重排序经典案例
// 两个线程分别执行 writer() 和 reader()
// ============================================================
public class ReorderingDemo {
 
    private int a = 0;          // 普通变量 a，初始值为 0
    private boolean flag = false; // 普通变量 flag，初始值为 false
 
    // 线程 A 执行的写方法
    public void writer() {
        a = 1;           // 操作 ①：先为 a 赋值
        flag = true;     // 操作 ②：再将 flag 设为 true，作为"数据就绪"信号
    }
 
    // 线程 B 执行的读方法
    public void reader() {
        if (flag) {          // 操作 ③：检查 flag 是否为 true
            int result = a;  // 操作 ④：如果 flag 为 true，读取 a 的值
            System.out.println(result); // 期望输出 1，但可能输出 0！
        }
    }
}

// ============================================================
// 使用 volatile 修复重排序问题
// ============================================================
public class VolatileOrderingFixed {
 
    private int a = 0;                    // 普通变量 a
    private volatile boolean flag = false; // volatile 变量 flag
 
    // 线程 A 执行的写方法
    public void writer() {
        a = 1;           // 操作 ①：普通写（在 volatile 写之前，不可被重排到 ② 之后）
        flag = true;     // 操作 ②：volatile 写（充当"内存屏障"，确保 ① 对其他线程可见）
    }
 
    // 线程 B 执行的读方法
    public void reader() {
        if (flag) {          // 操作 ③：volatile 读（一旦读到 true，之前的写都可见）
            int result = a;  // 操作 ④：普通读（在 volatile 读之后，不可被重排到 ③ 之前）
            System.out.println(result); // 现在保证输出 1 ✅
        }
    }
}

// ============================================================
// 查看 volatile 写生成的汇编指令
// 使用 JVM 参数: -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly
// ============================================================
public class VolatileAssembly {
 
    private volatile boolean flag = false; // volatile 变量
 
    public void setFlag() {
        flag = true; // volatile 写
    }
}
 
// setFlag() 方法在 x86-64 上可能生成如下汇编（简化）:
//
//   mov    $0x1, 0x10(%rdi)       ; 将 true (0x1) 写入 flag 字段偏移位置
//   lock addl $0x0, (%rsp)        ; StoreLoad 屏障！lock 前缀触发缓存一致性
//                                 ; addl $0x0 本身是空操作，仅为了触发 lock 语义
//
// 对比普通变量的写操作:
//   mov    $0x1, 0x10(%rdi)       ; 仅此一条指令，无额外屏障

// ============================================================
// 双重检查锁定单例 —— volatile 有序性的经典应用
// ============================================================
public class Singleton {
 
    // 必须声明为 volatile！关键在于禁止对象创建过程的指令重排序
    private static volatile Singleton instance;
 
    private int value; // 示例字段，在构造器中初始化
 
    private Singleton() {
        this.value = 42; // 构造器中为字段赋值
    }
 
    public static Singleton getInstance() {
        if (instance == null) {           // 第一次检查（无锁，快速路径）
            synchronized (Singleton.class) {
                if (instance == null) {   // 第二次检查（加锁后再次确认）
                    instance = new Singleton(); // 关键行！见下方分析
                }
            }
        }
        return instance;
    }
}

// 伪代码展示 new Singleton() 的底层步骤:
// Step 1: memory = allocate();       // 分配对象的内存空间
// Step 2: init(memory);              // 调用构造器，初始化对象（value = 42）
// Step 3: instance = memory;         // 将引用指向分配的内存地址

// 重排序后的执行顺序:
// Step 1: memory = allocate();       // 分配内存
// Step 3: instance = memory;         // 引用先指向内存（此时对象尚未初始化！）
// Step 2: init(memory);              // 构造器稍后才执行

public class OrderingQuiz {
    private int x = 0;
    private int y = 0;
    private volatile boolean ready = false;
 
    // 线程 A
    public void prepare() {
        x = 1;          // S1
        y = 2;          // S2
        ready = true;   // S3 (volatile 写)
    }
 
    // 线程 B
    public void consume() {
        if (ready) {        // L1 (volatile 读)
            int r1 = x;     // L2
            int r2 = y;     // L3
            System.out.println(r1 + " " + r2);
        }
    }
}

// 表面上的一行代码
i++;
 
// 实际上等价于以下三步操作：
// Step 1: READ  —— 从主内存读取 i 的当前值到工作内存（线程本地副本）
int temp = i;
// Step 2: MODIFY —— 在工作内存中对值进行 +1 计算
temp = temp + 1;
// Step 3: WRITE  —— 将计算结果写回主内存
i = temp;

public class VolatileAtomicityDemo {
 
    // 声明为 volatile，保证可见性，但不保证原子性
    private volatile int count = 0;
 
    // i++ 操作：看似简单，实则包含读-改-写三步
    public void increment() {
        count++; // 非原子操作！
    }
 
    public static void main(String[] args) throws InterruptedException {
        // 创建测试实例
        VolatileAtomicityDemo demo = new VolatileAtomicityDemo();
 
        // 创建 20 个线程，每个线程对 count 执行 1000 次自增
        Thread[] threads = new Thread[20];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    demo.increment(); // 每个线程累加 1000 次
                }
            });
            threads[i].start(); // 启动线程
        }
 
        // 等待所有线程执行完毕
        for (Thread t : threads) {
            t.join(); // 主线程阻塞，直到目标线程结束
        }
 
        // 期望结果：20 × 1000 = 20000
        // 实际结果：几乎每次都小于 20000！
        System.out.println("Expected: 20000");
        System.out.println("Actual:   " + demo.count);
    }
}

// javap -c VolatileAtomicityDemo.class 的输出（简化版）
public void increment();
    Code:
       0: aload_0                // 将 this 引用压入操作数栈
       1: dup                    // 复制栈顶的 this 引用（后续 putfield 需要）
       2: getfield #2            // 从堆内存读取 this.count 的值压入栈顶 ← READ
       5: iconst_1               // 将常量 1 压入操作数栈
       6: iadd                   // 弹出栈顶两个 int 相加，结果压回栈顶  ← MODIFY
       7: putfield #2            // 将栈顶结果写回 this.count            ← WRITE
      10: return                 // 方法返回

public class CompoundActionExamples {
 
    private volatile int value = 0;
    private volatile boolean flag = false;
 
    // ❌ 自减操作：同样是 读-改-写
    public void decrement() {
        value--; // getfield → iconst_1 → isub → putfield
    }
 
    // ❌ 复合赋值：value += 5 也是 读-改-写
    public void addFive() {
        value += 5; // getfield → iconst_5 → iadd → putfield
    }
 
    // ❌ check-then-act（检查后执行）模式
    // 在 check 和 act 之间，其他线程可能已经修改了 flag
    public void checkThenAct() {
        if (!flag) {          // Step 1: READ flag
            flag = true;      // Step 2: WRITE flag（两步之间可被打断！）
            // 多个线程可能同时通过 if 检查，都执行了 flag = true
        }
    }
 
    // ❌ 读取-比较-交换（Read-Compare-Swap）模式
    public void updateIfEquals(int expected, int newValue) {
        if (value == expected) {   // READ + COMPARE
            value = newValue;      // WRITE（比较和写入之间可被打断！）
        }
    }
}

import java.util.concurrent.atomic.AtomicInteger;
 
public class AtomicSolution {
 
    // 使用 AtomicInteger 替代 volatile int
    // AtomicInteger 内部持有一个 volatile int value
    // 并通过 CAS 操作保证自增的原子性
    private AtomicInteger count = new AtomicInteger(0);
 
    public void increment() {
        // incrementAndGet() 底层调用 Unsafe.compareAndSwapInt()
        // 实现原子的 读-改-写 操作
        // 等价于原子版的 ++count
        count.incrementAndGet();
    }
 
    public static void main(String[] args) throws InterruptedException {
        AtomicSolution demo = new AtomicSolution();
 
        // 与之前相同的测试：20 个线程各执行 1000 次自增
        Thread[] threads = new Thread[20];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    demo.increment(); // 原子自增
                }
            });
            threads[i].start();
        }
 
        // 等待所有线程完成
        for (Thread t : threads) {
            t.join();
        }
 
        // 使用 AtomicInteger 后，结果永远正确：20000
        System.out.println("Expected: 20000");
        System.out.println("Actual:   " + demo.count.get()); // 100% 输出 20000
    }
}

// AtomicInteger 的 incrementAndGet 伪代码还原
// （实际实现在 Unsafe 类中，通过 JNI 调用 CPU 的 CAS 指令）
public final int incrementAndGet() {
    int oldValue;        // 存储读取到的旧值
    int newValue;        // 存储计算出的新值
    do {
        oldValue = get();           // Step 1: 读取当前值（volatile 读）
        newValue = oldValue + 1;    // Step 2: 计算新值
        // Step 3: CAS 尝试将 oldValue 更新为 newValue
        // 如果主内存中 value 仍然等于 oldValue，则更新成功，返回 true
        // 如果主内存中 value 已被其他线程修改（!= oldValue），则更新失败，返回 false
    } while (!compareAndSwap(oldValue, newValue));  // 失败则重试（自旋）
    return newValue;     // 返回更新后的值
}

// ===================== 常用原子类一览 =====================
 
// 1. 基本类型原子类
AtomicInteger atomicInt = new AtomicInteger(0);     // 原子 int
AtomicLong atomicLong = new AtomicLong(0L);          // 原子 long
AtomicBoolean atomicBool = new AtomicBoolean(false); // 原子 boolean
 
// 2. 引用类型原子类
AtomicReference<String> atomicRef                    // 原子引用
    = new AtomicReference<>("initial");
AtomicStampedReference<String> stampedRef             // 带版本号的原子引用（解决 ABA 问题）
    = new AtomicStampedReference<>("init", 0);
AtomicMarkableReference<String> markableRef           // 带标记的原子引用
    = new AtomicMarkableReference<>("init", false);
 
// 3. 数组原子类
AtomicIntegerArray atomicIntArr                      // int 数组中每个元素的原子操作
    = new AtomicIntegerArray(10);
AtomicLongArray atomicLongArr                        // long 数组中每个元素的原子操作
    = new AtomicLongArray(10);
AtomicReferenceArray<String> atomicRefArr            // 引用数组中每个元素的原子操作
    = new AtomicReferenceArray<>(10);
 
// 4. JDK 8 新增的高性能累加器（高并发场景推荐）
LongAdder longAdder = new LongAdder();               // 高性能 long 累加器
LongAccumulator longAcc                              // 通用 long 累积器
    = new LongAccumulator(Long::max, Long.MIN_VALUE);
DoubleAdder doubleAdder = new DoubleAdder();          // 高性能 double 累加器

import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;
 
public class AdderVsAtomicBenchmark {
 
    // AtomicLong：所有线程 CAS 竞争同一个 value
    private static final AtomicLong atomicLong = new AtomicLong(0);
 
    // LongAdder：内部将竞争分散到多个 Cell，最终 sum() 汇总
    private static final LongAdder longAdder = new LongAdder();
 
    public static void main(String[] args) throws InterruptedException {
        int threadCount = 50;        // 50 个线程
        int loopCount = 1_000_000;   // 每线程累加 100 万次
 
        // ---------- 测试 AtomicLong ----------
        long start1 = System.currentTimeMillis();           // 记录开始时间
        Thread[] threads1 = new Thread[threadCount];
        for (int i = 0; i < threadCount; i++) {
            threads1[i] = new Thread(() -> {
                for (int j = 0; j < loopCount; j++) {
                    atomicLong.incrementAndGet();            // CAS 自增
                }
            });
            threads1[i].start();
        }
        for (Thread t : threads1) t.join();                 // 等待全部完成
        long end1 = System.currentTimeMillis();             // 记录结束时间
        System.out.println("AtomicLong result: " + atomicLong.get()
                + " | Time: " + (end1 - start1) + "ms");
 
        // ---------- 测试 LongAdder ----------
        long start2 = System.currentTimeMillis();           // 记录开始时间
        Thread[] threads2 = new Thread[threadCount];
        for (int i = 0; i < threadCount; i++) {
            threads2[i] = new Thread(() -> {
                for (int j = 0; j < loopCount; j++) {
                    longAdder.increment();                  // 分段累加
                }
            });
            threads2[i].start();
        }
        for (Thread t : threads2) t.join();                 // 等待全部完成
        long end2 = System.currentTimeMillis();             // 记录结束时间
        System.out.println("LongAdder  result: " + longAdder.sum()
                + " | Time: " + (end2 - start2) + "ms");
 
        // 典型输出（因机器而异）：
        // AtomicLong result: 50000000 | Time: 1523ms
        // LongAdder  result: 50000000 | Time: 238ms
        // LongAdder 在高竞争下快 5~10 倍
    }
}

public class SynchronizedSolution {
 
    // 不需要 volatile，因为 synchronized 本身保证可见性 + 原子性
    private int count = 0;
 
    // 方案 A：synchronized 方法
    // 同一时刻只有一个线程能进入此方法
    public synchronized void increment() {
        count++; // 在锁的保护下，读-改-写 变为原子操作
    }
 
    // 方案 B：synchronized 代码块（锁粒度更细，性能更好）
    private final Object lock = new Object(); // 专用锁对象
    public void incrementWithBlock() {
        synchronized (lock) { // 仅锁住临界区
            count++;          // 受锁保护的原子操作
        }
    }
 
    // 方案 C：ReentrantLock（功能更丰富：可中断、可超时、公平锁）
    private final java.util.concurrent.locks.ReentrantLock reentrantLock
        = new java.util.concurrent.locks.ReentrantLock();
 
    public void incrementWithLock() {
        reentrantLock.lock();     // 获取锁
        try {
            count++;              // 受锁保护的原子操作
        } finally {
            reentrantLock.unlock(); // 无论是否异常，都必须在 finally 中释放锁
        }
    }
}

public class PracticalChoiceDemo {
 
    // ========= 场景 1：停止标志 → 用 volatile =========
    // 只有简单的 boolean 赋值（true/false），无复合操作
    // volatile 就足够了，无需原子类或锁
    private volatile boolean running = true;
 
    public void stop() {
        running = false; // 单次写操作，volatile 保证可见性即可
    }
 
    public void run() {
        while (running) { // 单次读操作，能立即感知到 running 的变化
            // do work...
        }
    }
 
    // ========= 场景 2：并发计数器 → 用 AtomicInteger =========
    // 需要原子的 读-改-写，但不涉及多变量联动
    // AtomicInteger 比 synchronized 性能更好
    private final AtomicInteger requestCount = new AtomicInteger(0);
 
    public void onRequest() {
        requestCount.incrementAndGet(); // CAS 原子自增
    }
 
    public int getRequestCount() {
        return requestCount.get(); // volatile 读，保证获取最新值
    }
 
    // ========= 场景 3：银行转账 → 必须用锁 =========
    // 涉及两个变量（两个账户余额）的联合更新
    // 必须保证"扣款"和"加款"作为一个整体执行
    // 原子类无法覆盖此场景（只能保证单变量的原子性）
    private int balanceA = 1000; // 账户 A 余额
    private int balanceB = 1000; // 账户 B 余额
    private final Object transferLock = new Object(); // 转账锁
 
    public void transfer(int amount) {
        synchronized (transferLock) { // 锁住整个转账过程
            if (balanceA >= amount) {  // 检查余额是否充足
                balanceA -= amount;    // 从 A 扣款
                balanceB += amount;    // 向 B 加款
                // 两步操作在锁的保护下不可被打断
            }
        }
    }
}

private volatile int count = 0;
// 20 threads × 1000 increments each

// ========== 汇编层面：volatile 写操作的实际输出（x86-64）==========
 
// 假设 Java 代码为: volatile int flag = 1;
// JIT 编译后的核心汇编指令如下：
 
mov    DWORD PTR [rdi+0x10], 0x1   // 将值 1 写入 flag 字段的内存地址
                                    // rdi+0x10 是对象头偏移后 flag 字段的地址
 
lock addl $0x0, (%rsp)             // lock 前缀指令：对栈顶加 0（实际值不变）
                                    // 这条指令的真正目的不是 "加 0"
                                    // 而是利用 lock 前缀触发以下硬件行为：
                                    // 1. 将当前 CPU 核心的 Store Buffer 全部刷出
                                    // 2. 通过缓存一致性协议通知其他核心
                                    //    使其持有的对应缓存行失效（Invalidate）
                                    // 3. 充当一个 Full Memory Barrier（全屏障）

// ========== Store Buffer 与 Invalidate Queue 的存在导致的问题 ==========
 
// ---- 没有 volatile 时的可能执行场景 ----
 
// Core 1 执行:
running = false;     // 值写入 Store Buffer, 尚未刷到 L1 Cache
                     // MESI Invalidate 尚未发出, 或已发出但...
 
// Core 0 执行:
if (running) {       // Core 0 的 Invalidate Queue 中可能有待处理消息
                     // 但 CPU 选择先从自己的 L1 Cache 读取（仍为 true）
    doWork();        // 错误地继续执行！
}
 
// ---- 有 volatile 时的执行场景 ----
 
// Core 1 执行:
// volatile running = false;
// JIT 编译为:
//   mov [running_addr], 0       -- 写入值
//   lock addl $0x0, (%rsp)     -- lock 前缀强制：
//                                  1. 清空 Store Buffer (刷出所有挂起的写操作)
//                                  2. 等待所有 Invalidate ACK 返回
 
// Core 0 执行:
// volatile 读 running
// lock 前缀 / 内存屏障强制:
//   1. 处理 Invalidate Queue 中的所有待处理消息
//   2. 发现 running 的缓存行已被标记为 Invalid
//   3. 重新从主内存 (或持有最新值的核心) 读取
// 读到 false, 正确！

// ========== volatile 写操作的屏障插入模型 ==========
 
// --- 在 volatile 写之前 ---
StoreStore_Barrier();   // 屏障 1: 确保 volatile 写之前的所有普通写操作
                        //         已经刷入缓存, 对其他处理器可见
                        //         防止上面的普通写与下面的 volatile 写重排序
 
volatile_field = value; // volatile 写操作本体
 
// --- 在 volatile 写之后 ---
StoreLoad_Barrier();    // 屏障 2: 这是最关键也最昂贵的屏障
                        //         确保 volatile 写已完全刷入并可见后,
                        //         才能执行后续的任何读/写操作
                        //         防止 volatile 写与后面的 volatile 读重排序

// ========== volatile 读操作的屏障插入模型 ==========
 
value = volatile_field; // volatile 读操作本体
 
// --- 在 volatile 读之后 ---
LoadLoad_Barrier();     // 屏障 1: 确保 volatile 读完成后,
                        //         才能执行后续的普通读操作
                        //         防止 volatile 读与后面的普通读重排序
 
LoadStore_Barrier();    // 屏障 2: 确保 volatile 读完成后,
                        //         才能执行后续的普通写操作
                        //         防止 volatile 读与后面的普通写重排序

// ========== 完整示例：内存屏障在真实代码中的插入位置 ==========
public class VolatileBarrierDemo {
    int a = 0;                      // 普通变量
    int b = 0;                      // 普通变量
    volatile boolean flag = false;  // volatile 变量
 
    // ---- Writer 线程 ----
    public void writer() {
        a = 1;                      // 1. 普通写
        b = 2;                      // 2. 普通写
 
        // <<<< StoreStore 屏障 >>>>
        // 确保 a=1, b=2 的写操作在 flag=true 之前刷入缓存
        // 这样其他线程一旦看到 flag==true, 就一定能看到 a==1, b==2
 
        flag = true;                // 3. volatile 写
 
        // <<<< StoreLoad 屏障 >>>>
        // 确保 flag=true 已完全可见后, 才能执行后续的任何读写
        // 在 x86 上, 这里会生成 lock addl $0x0, (%rsp)
    }
 
    // ---- Reader 线程 ----
    public void reader() {
        if (flag) {                 // 4. volatile 读
 
            // <<<< LoadLoad 屏障 >>>>
            // 确保 flag 的值已读取完毕后, 才能读 a 和 b
            // <<<< LoadStore 屏障 >>>>
            // 确保 flag 的值已读取完毕后, 才能进行后续写操作
 
            int r1 = a;             // 5. 普通读 —— 保证读到 a=1
            int r2 = b;             // 6. 普通读 —— 保证读到 b=2
            System.out.println(r1 + ", " + r2); // 输出: 1, 2
        }
    }
}

public class WeightComparison {
 
    // ====== volatile 方案：轻量 ======
    // 仅一个修饰符，无需额外的锁对象，无需代码块
    private volatile boolean running = true;
 
    // 读操作：直接读取，JVM 自动插入 Load 屏障
    public boolean isRunning() {
        return running;  // volatile 读，开销约等于普通读（x86 下）
    }
 
    // 写操作：直接赋值，JVM 自动插入 Store 屏障
    public void stop() {
        running = false; // volatile 写，仅一条 lock 前缀指令
    }
 
    // ====== synchronized 方案：重量 ======
    // 需要一个专门的锁对象（或使用 this）
    private boolean flag = true;
    private final Object lock = new Object(); // 额外的锁对象
 
    // 读操作：必须获取锁 → 读取 → 释放锁
    public boolean getFlag() {
        synchronized (lock) {         // monitorenter：获取锁
            return flag;              // 读取共享变量
        }                             // monitorexit：释放锁
        // 即使只读一个 boolean，也要完成完整的加锁/解锁流程
    }
 
    // 写操作：同样必须走完整的锁流程
    public void clearFlag() {
        synchronized (lock) {         // monitorenter
            flag = false;             // 写入共享变量
        }                             // monitorexit
    }
}

public class AtomicityComparison {
 
    // ====== volatile 方案：不安全！ ======
    private volatile int volatileCount = 0;
 
    // i++ 看似一行代码，实际上是三步操作
    public void unsafeIncrement() {
        volatileCount++;
        // 字节码层面分解为：
        // 1. getfield  volatileCount  → 从主内存读取当前值（volatile 读）
        // 2. iconst_1 + iadd           → 在线程本地栈上执行 +1
        // 3. putfield  volatileCount  → 将新值写回主内存（volatile 写）
        //
        // 问题：在步骤 1 和步骤 3 之间，其他线程可能已经修改了 volatileCount！
        // volatile 只保证每次读到的是最新值，但不保证 "读→改→写" 的整体原子性
    }
 
    // ====== synchronized 方案：安全 ======
    private int syncCount = 0;
 
    public synchronized void safeIncrement() {
        syncCount++;
        // 虽然同样是三步操作，但 synchronized 确保：
        // 在当前线程执行完 读→改→写 并释放锁之前，
        // 其他线程根本无法进入这个方法，所以不会出现竞态条件
    }
}

import java.util.concurrent.atomic.AtomicInteger;
 
public class ThreeSolutions {
 
    // 方案 1: synchronized —— 最重，但最通用
    private int count1 = 0;
    public synchronized void increment1() {
        count1++; // 互斥保证，绝对安全
    }
 
    // 方案 2: AtomicInteger —— 基于 CAS 的无锁方案
    // 比 synchronized 轻量，比 volatile 安全
    private AtomicInteger count2 = new AtomicInteger(0);
    public void increment2() {
        count2.incrementAndGet(); // 内部使用 CAS 循环，保证原子性
        // CAS = Compare And Swap，是 CPU 级别的原子指令
        // 若在 CAS 时发现值已被修改，会自动重试（自旋）
    }
 
    // 方案 3: LongAdder —— 高并发下性能最优
    // 分段计数，减少 CAS 竞争，适合统计场景
    private java.util.concurrent.atomic.LongAdder count3
            = new java.util.concurrent.atomic.LongAdder();
    public void increment3() {
        count3.increment(); // 内部将计数分散到多个 Cell 中
        // 最终通过 sum() 汇总所有 Cell 的值
    }
}

public class NonBlockingExample {
 
    // ====== volatile：线程永不阻塞 ======
    private volatile boolean shutdownRequested = false;
 
    // 任何线程在任何时刻都可以调用，立即返回，绝不阻塞
    public void requestShutdown() {
        shutdownRequested = true; // volatile 写：纳秒级完成
    }
 
    // 工作线程在循环中检查标志，也绝不阻塞
    public void doWork() {
        while (!shutdownRequested) {   // volatile 读：纳秒级完成
            performTask();             // 执行具体业务
        }
        cleanup();                     // 检测到停止标志，优雅退出
    }
 
    // ====== synchronized：可能阻塞，在高频调用中成为瓶颈 ======
    private boolean syncShutdown = false;
    private final Object lock = new Object();
 
    public void syncRequestShutdown() {
        synchronized (lock) {          // 如果锁被其他线程持有 → 阻塞等待！
            syncShutdown = true;
        }
    }
 
    public void syncDoWork() {
        while (true) {
            synchronized (lock) {      // 每次循环都要竞争锁 → 性能噩梦！
                if (syncShutdown) break;
            }
            performTask();
        }
        cleanup();
    }
 
    private void performTask() { /* 业务逻辑 */ }
    private void cleanup() { /* 清理资源 */ }
}

public class DeadlockRisk {
 
    private final Object lockA = new Object();
    private final Object lockB = new Object();
 
    // synchronized 的死锁场景：
    // Thread-1 执行 method1()，Thread-2 执行 method2() → 死锁！
    public void method1() {
        synchronized (lockA) {             // Thread-1 持有 lockA
            synchronized (lockB) {         // Thread-1 等待 lockB → 被 Thread-2 持有
                // 业务逻辑
            }
        }
    }
 
    public void method2() {
        synchronized (lockB) {             // Thread-2 持有 lockB
            synchronized (lockA) {         // Thread-2 等待 lockA → 被 Thread-1 持有
                // 业务逻辑              // 两个线程互相等待 → 永久阻塞！
            }
        }
    }
 
    // volatile 方案：永远不会死锁
    // 因为根本没有"持有-等待"的概念
    private volatile int stateA = 0;
    private volatile int stateB = 0;
 
    public void safeMethod1() {
        stateA = 1;        // 直接写，无需获取任何锁
        int b = stateB;    // 直接读，无需获取任何锁
        // 不存在 "持有 A 等待 B" 的情况
    }
}

public class BrokenStopFlag {
    // 没有 volatile 修饰，工作内存中的副本可能永远不会刷新
    private static boolean running = true;
 
    public static void main(String[] args) throws InterruptedException {
        // 启动工作线程，持续循环直到 running 变为 false
        Thread worker = new Thread(() -> {
            int count = 0;
            // 工作线程可能一直读取自己工作内存中的 running = true
            // 导致循环永远不会终止
            while (running) {
                count++;
            }
            System.out.println("Worker stopped, count = " + count);
        });
        worker.start(); // 启动工作线程
 
        // 主线程休眠 1 秒后，尝试通知工作线程停止
        Thread.sleep(1000);
        running = false; // 主线程修改 running 为 false
        System.out.println("Main thread set running = false");
    }
}

// JIT 可能的激进优化：将变量提升到循环外部（hoisting）
// 因为 running 没有 volatile 修饰，JIT 认为没有其他线程能"合法"修改它
if (running) {
    while (true) { // 变成了死循环！
        count++;
    }
}

public class VolatileStopFlag {
    // 使用 volatile 修饰，保证所有线程看到的都是最新值
    private static volatile boolean running = true;
 
    public static void main(String[] args) throws InterruptedException {
        // 启动工作线程
        Thread worker = new Thread(() -> {
            int count = 0;
            // 每次循环判断时，都会从主内存重新读取 running 的最新值
            // volatile 阻止了 JIT 的 hoisting 优化
            while (running) {
                count++;  // 业务逻辑
            }
            // 当主线程将 running 设为 false 后，工作线程能立即感知到
            System.out.println("Worker stopped, count = " + count);
        });
        worker.start(); // 启动工作线程
 
        // 主线程休眠 1 秒
        Thread.sleep(1000);
 
        // 主线程修改 volatile 变量
        // 写入操作会立即刷新到主内存
        // 同时使其他 CPU 缓存行中的 running 副本失效
        running = false;
        System.out.println("Main thread set running = false");
    }
}

public class GracefulShutdown implements Runnable {
    // volatile 停止标志：用于非阻塞状态下的快速检测
    private volatile boolean stopped = false;
 
    // 保存工作线程的引用，用于发送中断信号
    private Thread workerThread;
 
    // 启动方法：创建并启动工作线程
    public void start() {
        workerThread = new Thread(this, "Worker");  // 创建线程并命名
        workerThread.start();                        // 启动线程
    }
 
    // 停止方法：设置标志 + 发送中断
    public void stop() {
        stopped = true;               // 先设置 volatile 标志（处理非阻塞场景）
        workerThread.interrupt();      // 再发送中断信号（处理阻塞场景）
    }
 
    @Override
    public void run() {
        // 双重检查：volatile 标志 + 中断状态
        // 两者缺一不可：
        //   - volatile 标志：处理 CPU 密集型循环，响应更快
        //   - 中断状态：处理线程在 sleep/wait/join 中阻塞的情况
        while (!stopped && !Thread.currentThread().isInterrupted()) {
            try {
                // 模拟业务处理
                doWork();
 
                // 如果线程在 sleep 期间被 interrupt()，
                // 会抛出 InterruptedException 并清除中断标志
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // sleep 被中断，说明收到了停止信号
                // InterruptedException 会清除中断标志，需要重新设置
                Thread.currentThread().interrupt();  // 恢复中断状态
                break;                               // 退出循环
            }
        }
        // 执行清理工作
        cleanup();
    }
 
    private void doWork() {
        // 业务逻辑...
    }
 
    private void cleanup() {
        // 资源释放、状态持久化等收尾工作...
        System.out.println("Worker cleaned up and exited gracefully.");
    }
}

public class UnsafeSingleton {
    private static UnsafeSingleton instance;  // 单例引用，未加任何保护
 
    public static UnsafeSingleton getInstance() {
        if (instance == null) {         // 线程 A 判断为 null
            // 线程 A 被切换出去，线程 B 也进来判断为 null
            // 两个线程各创建了一个实例！单例被破坏！
            instance = new UnsafeSingleton();
        }
        return instance;
    }
}

public class SynchronizedSingleton {
    private static SynchronizedSingleton instance;
 
    // 每次调用 getInstance() 都要获取锁
    // 即使 instance 早已初始化完成，仍然需要同步
    // 在高并发场景下，所有线程串行排队，成为性能瓶颈
    public static synchronized SynchronizedSingleton getInstance() {
        if (instance == null) {
            instance = new SynchronizedSingleton();
        }
        return instance;
    }
}

public class BrokenDCL {
    // 没有 volatile！这是 Bug 的根源！
    private static BrokenDCL instance;
 
    public static BrokenDCL getInstance() {
        if (instance == null) {              // 第一次检查（无锁）：快速路径
            synchronized (BrokenDCL.class) { // 加锁：只有首次初始化时才会进入
                if (instance == null) {      // 第二次检查（有锁）：防止重复创建
                    instance = new BrokenDCL(); // 问题出在这一行！
                }
            }
        }
        return instance; // 可能返回一个"半初始化"的对象！
    }
}

// instance = new BrokenDCL() 的字节码拆解
 
// 步骤 ①：分配内存空间
memory = allocate();           // 在堆上分配对象所需的内存
 
// 步骤 ②：初始化对象
constructInstance(memory);     // 调用构造函数，初始化成员变量
 
// 步骤 ③：引用指向内存
instance = memory;             // 将 instance 引用指向分配的内存地址

// 重排序后的执行顺序：①→③→②
 
memory = allocate();           // ① 分配内存
instance = memory;             // ③ 引用赋值（此时 instance ≠ null 了！）
                               //    但对象的构造函数还没执行！
constructInstance(memory);     // ② 初始化对象（此时才真正完成初始化）

public class Singleton {
    // volatile 是 DCL 正确性的关键保障！
    // 它禁止了 instance 赋值操作与构造函数之间的指令重排序
    private static volatile Singleton instance;
 
    // 私有构造函数，防止外部直接 new
    private Singleton() {
        // 初始化成员变量...
    }
 
    public static Singleton getInstance() {
        // 第一次检查（无锁）：性能优化的关键
        // 当 instance 已初始化后，所有线程都在这里直接返回
        // 不需要获取锁，性能接近无同步的版本
        if (instance == null) {
            // 只有在 instance 尚未初始化时，才进入同步块
            synchronized (Singleton.class) {
                // 第二次检查（有锁）：防止多个线程同时通过第一次检查后重复创建
                // 线程 A 创建完成后，线程 B 进入同步块会发现 instance 已不为 null
                if (instance == null) {
                    // volatile 保证了这行代码的执行顺序：
                    // ① allocate → ② construct → ③ assign
                    // 步骤 ② 一定在步骤 ③ 之前完成
                    // 外部线程读到非 null 的 instance 时，对象一定已完全初始化
                    instance = new Singleton();
                }
            }
        }
        // 返回完全初始化的单例对象
        return instance;
    }
}

public class Singleton {
    // 私有构造函数
    private Singleton() {}
 
    // 静态内部类：JVM 保证类加载过程是线程安全的
    // SingletonHolder 只有在首次被引用时才会加载
    // 即首次调用 getInstance() 时才触发 Singleton 的实例化
    private static class SingletonHolder {
        // 类加载阶段由 JVM 保证线程安全，无需手动同步
        static final Singleton INSTANCE = new Singleton();
    }
 
    public static Singleton getInstance() {
        // 触发 SingletonHolder 的类加载 → 触发 INSTANCE 的初始化
        return SingletonHolder.INSTANCE;
    }
}

public enum Singleton {
    INSTANCE;  // 枚举常量，JVM 保证全局唯一，天然防反射、防序列化
 
    // 枚举也可以定义成员变量和方法
    private final SomeService service = new SomeService();
 
    public SomeService getService() {
        return service;
    }
}

public class UnsafePublish {
    // 一个普通的（非 volatile）引用
    private static HeavyObject resource;
 
    // 初始化方法：由某个线程调用
    public static void initialize() {
        // HeavyObject 构造函数中会初始化多个字段
        resource = new HeavyObject();
    }
 
    // 使用方法：由其他线程调用
    public static void use() {
        if (resource != null) {
            // 危险！即使 resource 不为 null，
            // 也不能保证 HeavyObject 内部的字段已经全部初始化完成
            // 这与 DCL 中的问题本质相同：指令重排 + 缓存不一致
            resource.doSomething();
        }
    }
}

public class HeavyObject {
    private int[] data;      // 内部数组
    private String name;     // 名称
    private boolean ready;   // 就绪标志
 
    public HeavyObject() {
        data = new int[1000];             // 分配并初始化数组
        Arrays.fill(data, 42);            // 填充数据
        name = "initialized";             // 设置名称
        ready = true;                     // 设置就绪标志
    }
 
    public void doSomething() {
        if (!ready) {
            // 理论上不应该走到这里，但没有 volatile 保护的话，
            // 其他线程可能看到 ready = false（默认值）
            throw new IllegalStateException("Object not ready!");
        }
        // 使用 data 和 name...
        System.out.println(name + ": " + data[0]);
    }
}

public class SafePublish {
    // volatile 保证：当其他线程看到 resource 不为 null 时，
    // HeavyObject 的构造函数一定已经完全执行完毕
    // 所有内部字段一定已经初始化到正确的值
    private static volatile HeavyObject resource;
 
    // 初始化方法
    public static void initialize() {
        // volatile 写入之前的所有普通写入（构造函数中的字段赋值）
        // 都会通过 StoreStore 屏障被刷新到主内存
        // 然后才执行 volatile 写（引用赋值）
        resource = new HeavyObject();
    }
 
    // 使用方法
    public static void use() {
        // 将 volatile 引用读到本地变量，避免多次 volatile 读的性能开销
        HeavyObject local = resource;
        if (local != null) {
            // volatile 读之后的所有普通读（访问 local 的字段）
            // 都能看到 volatile 写之前的所有写入
            // 这就是 volatile 的 happens-before 传递性
            local.doSomething();  // 安全！对象一定是完全初始化的
        }
    }
}

public class ConfigManager {
    // volatile 引用：保证配置对象的安全发布
    // 其他线程读取 config 时，一定能看到完全初始化的 Config 对象
    private volatile Config config;
 
    // 初始化或重新加载配置
    // 注意：新建一个全新的 Config 对象，而不是修改现有对象的字段
    // 这是"不可变对象 + volatile 引用"的经典模式
    public void reloadConfig() {
        // 在局部变量中完成所有初始化工作
        Config newConfig = new Config();           // 创建新对象
        newConfig.setTimeout(5000);                // 设置超时时间
        newConfig.setMaxRetries(3);                // 设置最大重试次数
        newConfig.setEndpoint("https://api.com");  // 设置端点地址
        // 所有初始化完成后，一次性通过 volatile 写发布
        // volatile 保证上面三行 setter 的写入在赋值之前全部可见
        config = newConfig;
    }
 
    // 使用配置
    public void handleRequest() {
        // 读取 volatile 引用到本地变量（性能优化 + 一致性快照）
        Config snapshot = config;
        if (snapshot != null) {
            // 使用 snapshot 而不是反复读 config
            // 保证在整个方法内使用的是同一个 Config 对象
            int timeout = snapshot.getTimeout();
            int retries = snapshot.getMaxRetries();
            // ... 业务逻辑
        }
    }
}