volatile 详解

/**
 * 飞翔科技 - 系统运行状态标志位 volatile 可见性演示
 * 
 * 场景：3 个工作线程（数据采集、日志分析、告警检查）
 *       管理员大翔(工号10001)发出停机指令，所有线程立即感知
 */
public class SystemMonitorDemo {

    // ★ volatile — 保证 running 的修改对所有线程可见
    //   如果不加 volatile，工作线程可能永远看不到 main 线程的修改
    private static volatile boolean running = true;

    // 使用 synchronized 保护的非 volatile 计数器（仅用于统计）
    private static int processedCount = 0;
    private static final Object countLock = new Object();

    static class WorkerThread extends Thread {
        private final String workerName;

        public WorkerThread(String name) {
            super(name);
            this.workerName = name;
        }

        @Override
        public void run() {
            int localCount = 0;
            System.out.printf("[%s] 启动，开始监控...\n", workerName);

            // ★ 循环检测 volatile 标志位 — 每次读取都从主内存获取最新值
            while (running) {
                try {
                    Thread.sleep(100); // 模拟每次处理耗时 100ms
                } catch (InterruptedException e) {
                    System.out.printf("[%s] 收到中断信号\n", workerName);
                    break;
                }

                localCount++;
                synchronized (countLock) {
                    processedCount++;
                }

                if (localCount % 10 == 0) {
                    System.out.printf("[%s] 已处理 %d 条数据...\n", workerName, localCount);
                }
            }

            System.out.printf("[%s] 检测到停机标志，正在退出...(共处理 %d 条)\n",
                    workerName, localCount);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        System.out.println("========== 飞翔科技系统监控平台 ==========\n");

        // 启动 3 个工作线程
        WorkerThread w1 = new WorkerThread("数据采集线程");
        WorkerThread w2 = new WorkerThread("日志分析线程");
        WorkerThread w3 = new WorkerThread("告警检查线程");

        w1.start();
        w2.start();
        w3.start();

        // 主线程（管理员大翔-10001）模拟系统运行 5 秒后停机
        System.out.println("[管理员-大翔-10001] 系统正常运行中，薪资结算基数 8888.88...\n");
        Thread.sleep(5000);

        System.out.println("\n[管理员-大翔-10001] 收到维护通知，发起系统停机...");
        // ★ 修改 volatile 变量 — 所有工作线程的 while(running) 立即可见
        running = false;
        System.out.println("[管理员-大翔-10001] 停机标志已设置，等待工作线程退出...\n");

        // 等待工作线程结束
        w1.join(3000);
        w2.join(3000);
        w3.join(3000);

        // 如果线程在 sleep 中，需要 interrupt
        w1.interrupt();
        w2.interrupt();
        w3.interrupt();

        w1.join();
        w2.join();
        w3.join();

        System.out.printf("\n========== 系统已安全停机 ==========\n");
        System.out.printf("总计处理数据: %d 条\n", processedCount);
        System.out.printf("管理员工号: 10001, 月薪参考: %.2f\n", 8888.88f);
    }
}

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 飞翔科技 - volatile 非原子性验证
 * 
 * 场景：10 个线程，每个线程执行 10000 次 count++
 *       volatile 修饰的计数器无法得到正确结果
 *       对比：synchronized 和 AtomicInteger 都是正确的
 */
public class VolatileAtomicityDemo {

    // ✗ volatile — 不能保证 count++ 的原子性（读-改-写三步）
    private static volatile int volatileCount = 0;

    // ✓ synchronized — 保证原子性
    private static int syncCount = 0;
    private static final Object lock = new Object();

    // ✓ AtomicInteger — 推荐方式
    private static final AtomicInteger atomicCount = new AtomicInteger(0);

    private static final int THREAD_COUNT = 10;
    private static final int ITERATIONS = 10000;
    private static final int EXPECTED = THREAD_COUNT * ITERATIONS; // 100000

    public static void main(String[] args) throws InterruptedException {
        System.out.println("========== 飞翔科技计数器非原子性验证 ==========");
        System.out.printf("线程数: %d | 每线程操作: %d | 期望: %d\n\n",
                THREAD_COUNT, ITERATIONS, EXPECTED);

        testVolatileCounter();
        testSynchronizedCounter();
        testAtomicCounter();

        System.out.println("\n========== 结论 ==========");
        System.out.println("volatile 只保证可见性，不能保证 count++ 的原子性。");
        System.out.println("复合操作必须使用 synchronized 或 AtomicInteger。");
    }

    private static void testVolatileCounter() throws InterruptedException {
        volatileCount = 0;
        CountDownLatch latch = new CountDownLatch(THREAD_COUNT);
        System.out.println("▶ 测试1: volatile int count = 0; count++");

        for (int i = 0; i < THREAD_COUNT; i++) {
            final int workerId = 10001 + i;
            new Thread(() -> {
                for (int j = 0; j < ITERATIONS; j++) {
                    volatileCount++; // 读-改-写，非原子！
                }
                latch.countDown();
            }, "Worker-" + workerId).start();
        }
        latch.await();
        System.out.printf("  结果: %d (期望: %d, 丢失: %d)\n\n",
                volatileCount, EXPECTED, EXPECTED - volatileCount);
    }

    private static void testSynchronizedCounter() throws InterruptedException {
        syncCount = 0;
        CountDownLatch latch = new CountDownLatch(THREAD_COUNT);
        System.out.println("▶ 测试2: synchronized 保护 count++");

        for (int i = 0; i < THREAD_COUNT; i++) {
            final int workerId = 10001 + i;
            new Thread(() -> {
                for (int j = 0; j < ITERATIONS; j++) {
                    synchronized (lock) { syncCount++; }
                }
                latch.countDown();
            }, "Worker-" + workerId).start();
        }
        latch.await();
        System.out.printf("  结果: %d (期望: %d)\n\n", syncCount, EXPECTED);
    }

    private static void testAtomicCounter() throws InterruptedException {
        atomicCount.set(0);
        CountDownLatch latch = new CountDownLatch(THREAD_COUNT);
        System.out.println("▶ 测试3: AtomicInteger 计数");

        for (int i = 0; i < THREAD_COUNT; i++) {
            final int workerId = 10001 + i;
            new Thread(() -> {
                for (int j = 0; j < ITERATIONS; j++) {
                    atomicCount.incrementAndGet(); // CAS 原子操作
                }
                latch.countDown();
            }, "Worker-" + workerId).start();
        }
        latch.await();
        System.out.printf("  结果: %d (期望: %d)\n\n", atomicCount.get(), EXPECTED);
    }
}

/**
 * 飞翔科技 - DCL 单例 volatile 防止指令重排
 * 
 * 场景：全局配置管理器，频繁被多线程访问
 *       volatile 确保 INSTANCE 的初始化不会被指令重排破坏
 */
public class DCLSingletonDemo {

    static class ConfigManager {
        // ★ volatile — 禁止指令重排，防止返回半成品对象
        private static volatile ConfigManager INSTANCE;

        private String dbUrl;
        private float maxSalary; // 飞翔科技薪资上限

        private ConfigManager() {
            // 模拟初始化耗时操作
            this.dbUrl = "jdbc:mysql://feixiang-db:3306/fx_tech";
            this.maxSalary = 8888.88f;
            System.out.println("ConfigManager 初始化完成");
        }

        public static ConfigManager getInstance() {
            // 第一次检查 — 避免不必要的同步
            if (INSTANCE == null) {
                // 同步块 — 只有一个线程能进入
                synchronized (ConfigManager.class) {
                    // 第二次检查 — 防止重复创建
                    if (INSTANCE == null) {
                        // ★ 如果没有 volatile，这里可能被指令重排：
                        //   1. 分配内存空间
                        //   2. INSTANCE 指向内存（此时对象还未初始化！）
                        //   3. 调用构造器初始化
                        //   → 线程B在步骤2后读到 INSTANCE != null，拿到半成品！
                        INSTANCE = new ConfigManager();
                    }
                }
            }
            return INSTANCE;
        }

        public float getMaxSalary() { return maxSalary; }
    }

    public static void main(String[] args) {
        System.out.println("========== 飞翔科技配置管理器 DCL 单例测试 ==========\n");

        // 10 个线程同时获取单例
        for (int i = 0; i < 10; i++) {
            final int workerId = 10001 + i;
            new Thread(() -> {
                ConfigManager cm = ConfigManager.getInstance();
                System.out.printf("[工号%d] 获取 ConfigManager, maxSalary=%.2f\n",
                        workerId, cm.getMaxSalary());
            }).start();
        }
    }
}

// ✗ 错误：volatile 修饰引用类型只能保证引用本身的可见性
//         数组元素/集合内容的修改不具有可见性
private volatile int[] data = new int[10];

// 线程A
data[0] = 100;  // ✗ 这个修改对其他线程不一定可见！

// ✓ 正确：使用 AtomicIntegerArray 或 synchronized 保护
// 或使用 volatile 只保证数组引用替换的可见性
data = newData;  // ✓ 引用替换是可见的

// ✗ 错误：i++ 是读-改-写三步操作，volatile 无法保证原子性
private volatile int count = 0;
// 多线程执行 count++ → 结果错误

// ✓ 正确：使用 AtomicInteger 或 synchronized
private final AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet();  // ✓ CAS 原子操作

// ✗ 错误：不加 volatile，INSTANCE = new Singleton() 可能被指令重排
private static Singleton INSTANCE;  // 缺少 volatile！

public static Singleton getInstance() {
    if (INSTANCE == null) {           // 第一次检查
        synchronized (Singleton.class) {
            if (INSTANCE == null) {   // 第二次检查
                INSTANCE = new Singleton(); // ⚠ 可能返回半成品对象！
            }
        }
    }
    return INSTANCE;
}

// ✓ 正确：加上 volatile
private static volatile Singleton INSTANCE;

// ✓ 正确：volatile 最适合用于简单的布尔标志位
private volatile boolean shutdown = false;

public void run() {
    while (!shutdown) {  // 每次读取都从主内存获取
        doWork();
    }
}

public void stop() {
    shutdown = true;  // 写入立即刷新到主内存
}