怎么解释 volatile 只能保证单次读写的原子性，而无法保证 i++ 这种复合操作的原子性？

volatile 保证单次读或写是原子的，这没错。但 i++ 这种操作，拆开来就完全是另一回事了——它本质上是“读-改-写”三连击，每一步之间都有可能被其他线程插一脚。很多初学者在这里栽跟头，就是因为没看透字节码层面的执行细节。

volatile 的读写操作本身就是原子的，但 i++ 不是单次读写

Ja va 语言规范白纸黑字写着：对 volatile 变量的单次读或单次写（比如 count = 5、int x = count）是原子的。但 i++ 在字节码层面一展开，就变成了三条独立的指令——iload（读）、iadd（算）、istore（写）。说白了，它是三个非原子步骤的组合，根本不是什么“一次性操作”。

即便每一步都作用在 volatile 变量上，JVM 也不承诺这三步“不可分割”。线程调度器随时可能在任意一步之后切走 CPU，让另一个线程插进来执行自己的 iload——结果就是两个线程读到了同一个旧值。

i++ 在多线程下丢失更新的具体过程

假设 volatile int count = 0，线程 A 和 B 同时执行 count++，咱们一步步看：

• 线程 A 读取 count == 0（可见性保证它读到最新值，没问题）
• 线程 B 也读取 count == 0（A 还没写回，B 看到的仍然是 0）
• A 计算出 1，写回 count = 1（volatile 写，立即刷主存）
• B 计算出 1，写回 count = 1（直接覆盖了 A 的结果）

最终 count == 1，而不是预想中的 2。问题不在于“读不到新值”，而在于“读-算-写”这个完整过程缺少互斥保护。

为什么 volatile 不能靠加内存屏障来兜住 i++？

volatile 写插入的内存屏障，只禁止其后的读/写被重排序到它前面；读插入的屏障，只禁止其前的读/写被重排序到它后面。它管的是指令顺序，不是执行临界区。

屏障能确保什么呢？
– A 写完 count = 1 后，B 一定能看到这个 1（这是可见性）；
– A 不会把 count = 1 提前到某个无关的 log 输出之前（这是有序性）；
但它完全不阻止 B 在 A 执行 iload 之后、istore 之前，也执行一次 iload。

这种“时间窗口内的竞态”，只能靠锁或者 CAS 这类机制来关闭，内存屏障管不了这个。

哪些操作看似简单，其实和 i++ 一样踩坑？

所有依赖当前值做计算再写回的操作，都逃不开这个问题：

• count += 1、count--、count *= 2——全是变种 i++
• if (flag) { doSomething(); flag = false; }——就算 flag 是 volatile，判断和置 false 是两步，中间可能被其他线程改掉
• volatile int[] arr = new int[1]; arr[0]++——数组引用本身可见，但 arr[0] 并不是 volatile，复合操作完全没保护

真正安全的 volatile 使用场景，仅限于：赋值、读取、作为状态开关（比如 shutdownRequested = true），并且不依赖该变量的旧值做任何逻辑分支或计算。一旦涉及“先读再写”，volatile 就靠不住了。