public class VisibilityProblem {
    // 缺少 volatile 关键字！
    private static boolean flag = false;
    public static void main(String[] args) throws InterruptedException {
        Thread writerThread = new Thread(() -> {
            try {
                Thread.sleep(1000); // 模拟业务逻辑耗时
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            flag = true; // 1秒后修改标志位
            System.out.println("标志位已设置为 true");
        });
        Thread readerThread = new Thread(() -> {
            while (!flag) {
                // 空循环，等待flag变为true
                // 由于flag的修改不可见，这个循环可能永远不会结束！
            }
            System.out.println("检测到标志位变为 true，循环结束");
        });
        writerThread.start();
        readerThread.start();
        writerThread.join();
        readerThread.join();
    }
}
// 运行结果可能是：writerThread打印后，readerThread永远无法结束。

private static volatile boolean flag = false; // 只需加上volatile

public class Singleton {
    // 使用volatile禁止指令重排序
    private static volatile Singleton instance;
    private Singleton() {} // 私有构造器
    public static Singleton getInstance() {
        if (instance == null) { // 第一次检查，避免不必要的同步
            synchronized (Singleton.class) { // 加锁
                if (instance == null) { // 第二次检查，确保唯一性
                    // 1. 为对象分配内存空间
                    // 2. 初始化对象（调用构造方法）
                    // 3. 将instance引用指向分配的内存地址
                    // 如果没有volatile，2和3可能被重排序，导致其他线程拿到未初始化的对象！
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public class TemperatureSensor {
    // 传感器读数只需被发布，无需其他同步
    private volatile double currentTemperature;
    public void run() {
        while (true) {
            // 独立地读取传感器数据
            double temp = readSensor();
            currentTemperature = temp; // 直接赋值，volatile保证其他线程立即可见
            // ... 其他逻辑
        }
    }
    public double getTemperature() {
        return currentTemperature; // 直接返回最新值
    }
}

public class AtomicityProblem {
    private volatile int count = 0; // 即使加了volatile也没用！
    public void increment() {
        count++; // 这个操作不是原子的！
        // 它实际上分为三步：
        // 1. 读取count的当前值 (read)
        // 2. 将值加1 (add)
        // 3. 写回新值 (write)
    }
    public static void main(String[] args) throws InterruptedException {
        AtomicityProblem problem = new AtomicityProblem();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                problem.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                problem.increment();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        // 结果几乎肯定小于 20000
        System.out.println("最终结果: " + problem.count);
    }
}