一篇文章深入聊聊Java的内存模型

// 原子操作示例
int x = 10;           // 原子的：一次性赋值
boolean flag = true;  // 原子的

// 非原子操作示例
int i = 0;
i++;                  // 非原子的，实际包含3个步骤：
                      // 1.读取i的值到寄存器 
                      // 2.寄存器值加1     
                      // 3.写回内存        

 private boolean running = true;  // 主内存中的变量
    
    public void run() {
        while (running) {  // 工作内存中的副本
            // 看不到running被改为false
        }
    }
    
    public void stop() {
        running = false;  // 修改主内存，但工作内存可能没更新
    }

 private int x = 0;
 private boolean flag = false;
    
    // 线程1执行
    public void writer() {
        x = 42;          // 1
        flag = true;     // 2 可能被重排到1之前！
    }
    
    // 线程2执行
    public void reader() {
        if (flag) {      // 3
            System.out.println(x);  // 可能输出0而不是42！
        }
    }

// 核心：happens-before ≠ 时间先后
int x = 0;
int y = 0;

// 时间上：先执行1，后执行2
x = 1;      // 1
y = x + 1;  // 2

// 逻辑上：1 happens-before 2
// 所以2一定能看到1写入的值

 private volatile boolean flag = false;
    private int count = 0;
    
    public void writer() {
        count = 42;        // 普通写操作
        flag = true;       // volatile写操作
    }
    
    public void reader() {
        if (flag) {        // volatile读操作
            // 这里一定能看到count=42
            System.out.println(count);
        }
    }

// 错误:以为volatile能保证原子性
volatile int count = 0;
count++;  // 非原子操作

// 正确:使用原子类或同步
AtomicInteger atomicCount = new AtomicInteger(0);
atomicCount.incrementAndGet();

// 可能由于重排序导致问题
int a = 0;
boolean flag = false;

// 线程1
a = 1;          // 1
flag = true;    // 2 可能重排到1之前

// 线程2
if (flag) {
    System.out.println(a);  // 可能输出0
}