深入理解Java内存模型(JMM)

/**
 * 重排序导致的可见性问题示例
 * 理论上result可能为0，违反直觉
 */
public class ReorderingDemo {
    private static int x = 0, y = 0;
    private static int a = 0, b = 0;

    public static void main(String[] args) throws InterruptedException {
        int count = 0;
        while (true) {
            x = 0; y = 0; a = 0; b = 0;
            count++;

            Thread t1 = new Thread(() -> {
                a = 1; // 语句1
                x = b; // 语句2
            });
            Thread t2 = new Thread(() -> {
                b = 1; // 语句3
                y = a; // 语句4
            });
            t1.start();
            t2.start();
            t1.join();
            t2.join();

            // 如果发生了重排序（语句2在语句1之前执行，语句4在语句3之前执行）
            // 那么x == 0 && y == 0 是可能出现的
            if (x == 0 && y == 0) {
                System.out.println("Reordering detected at iteration: " + count);
                break;
            }
        }
    }
}

/**
 * 虽然语句1 happens-before 语句2（程序顺序规则），
 * 但因为两者之间没有数据依赖，编译器/处理器可能重排序它们的实际执行顺序。
 * 只要最终结果与顺序执行一致即可。
 */
public class HappensBeforeDemo {
    public void example() {
        int a = 1;   // 语句1
        int b = 2;   // 语句2 -- 可能与语句1重排序
        int c = a + b; // 语句3 -- 依赖语句1和2，不能被重排到它们之前
    }
}

public class VolatileDemo {
    private volatile boolean flag = false;
    private int data = 0;

    /**
     * 线程A执行
     * 由于flag是volatile的：
     * - data = 42 不会被重排到 flag = true 之后
     * - flag = true 会立即刷新到主内存
     */
    public void writer() {
        data = 42;        // 普通写
        flag = true;      // volatile写 -- 充当内存屏障
    }

    /**
     * 线程B执行
     * 由于flag是volatile的：
     * - 读取flag会从主内存刷新
     * - 读取data不会被重排到读取flag之前
     * - 如果看到flag == true，则必然能看到data == 42
     */
    public void reader() {
        if (flag) {       // volatile读 -- 充当内存屏障
            System.out.println(data); // 保证输出42
        }
    }
}

/**
 * volatile不能保证复合操作的原子性
 * count++不是原子操作：read-modify-write
 */
public class VolatileNotAtomic {
    private volatile int count = 0;

    // 这个方法在多线程下是不安全的
    public void unsafeIncrement() {
        count++; // 非原子操作：读取 -> 加1 -> 写回
    }

    // 正确做法1：使用synchronized
    public synchronized void safeIncrement1() {
        count++;
    }

    // 正确做法2：使用AtomicInteger
    private final java.util.concurrent.atomic.AtomicInteger atomicCount =
        new java.util.concurrent.atomic.AtomicInteger(0);

    public void safeIncrement2() {
        atomicCount.incrementAndGet();
    }
}

public class Singleton {
    // 必须用volatile修饰，禁止指令重排序
    private static volatile Singleton instance;

    private Singleton() {
        // 私有构造函数
    }

    public static Singleton getInstance() {
        if (instance == null) {                 // 第一次检查（无锁）
            synchronized (Singleton.class) {
                if (instance == null) {         // 第二次检查（有锁）
                    instance = new Singleton(); // 关键点
                }
            }
        }
        return instance;
    }
}

public class FinalFieldExample {
    private final int x;
    private final int[] arr;
    private int y; // 普通字段，无特殊保证

    public FinalFieldExample() {
        x = 42;                     // final字段写入
        arr = new int[]{1, 2, 3};   // final字段写入（引用类型）
        y = 100;                    // 普通字段写入
    }
    // 构造函数结束时，会插入StoreStore屏障
    // 确保final字段在对象引用发布前已初始化完成

    /**
     * JMM保证：
     * 1. 在构造函数内对final字段的写入，与对象引用赋值不会重排序
     * 2. 其他线程通过对象引用首次读到final字段时，能看到正确的初始化值
     * 3. final引用类型指向的对象（如数组），其成员在构造函数中的初始化也有保证
     *
     * 前提条件：对象引用不能在构造函数中逸出（this引用不能泄露）
     */
    public static void reader(FinalFieldExample obj) {
        int localX = obj.x;      // 保证读到42
        int[] localArr = obj.arr; // 保证读到已初始化的数组
        int localY = obj.y;      // 不保证读到100（普通字段无保证）
    }
}

/**
 * 错误示例：构造函数中this引用逸出
 * final字段的可见性保证将失效
 */
public class ThisEscapeExample {
    private final int value;
    private static ThisEscapeExample instance;

    public ThisEscapeExample(int v) {
        instance = this; // 危险！this引用在构造函数完成前逸出
        value = v;       // final字段可能还未初始化
    }
    // 其他线程通过instance读取value时，可能看到默认值0而非v
}