外观
07 - CAS 与原子类
适用 JDK:JDK 8+。
前置阅读:03 - JMM 与 happens-before。本文先解释 CAS 如何完成一次原子更新,再讨论原子类的适用边界;硬件指令和内存屏障细节见 JVM 06 - Java 内存模型与并发底层。
摘要
两个线程同时执行普通计数器的 count++,可能都读到同一个旧值,随后写入同一个新值,丢掉一次累加。AtomicInteger 能把一次累加作为不可分割的更新完成。本文从 CAS 的“比较后更新”模型出发,解释原子类如何避免覆盖并发更新,以及为什么它仍有 ABA、重试成本和业务一致性边界。
1. CAS 的三个操作数
CAS(Compare-And-Set,比较并设置)是一种条件更新:比较与写入作为一个原子操作完成,其他线程不能插入两者之间。三个操作数分别是当前位置的值 V、调用方期望的旧值 E 和准备写入的新值 N:
text
如果当前值 V == 期望值 E:写入新值 N,返回成功
否则:不写入,返回失败下面是方法体片段,需导入 java.util.concurrent.atomic.AtomicInteger。本文 Java 示例均为教学片段,未编译运行;其他原子类和 LongAdder 也来自 java.util.concurrent.atomic 包。
java
AtomicInteger counter = new AtomicInteger();
counter.incrementAndGet();可以用“读取当前值、计算新值、CAS 写入,失败后重试”理解这次累加。例如,两个线程都读到 0,都准备写入 1:第一个 CAS 成功后,第二个以 0 为期望值的 CAS 就会失败。第二个线程必须重新读取 1、计算 2,再尝试更新,才能保留两次累加。
这是理解更新协议的模型,不是各 JDK 版本 incrementAndGet() 的逐行实现。CAS 的原子性最终依赖 JVM intrinsic(JVM 对特定方法的内建实现)和硬件原子指令,具体实现应按 JDK 与处理器确认。
上面的成功 CAS 有一个线性化点,即“比较成功并写入新值”的原子时刻。线性化指并发操作虽然在时间上重叠,仍能被解释为按某个符合实际先后关系的顺序逐个生效。失败的尝试没有提交更新;成功的尝试确定这次更新何时生效。
CAS 解决的是“当前值仍等于我刚才读到的值时才更新”,不是保证任意一段业务代码都不受并发干扰。
2. 什么时候适合原子类
原子类适合单个状态的原子更新,例如序列号、指标计数、不可变配置快照的整体替换。下面的类片段需要导入 AtomicLong:
java
public final class Sequence {
private final AtomicLong value = new AtomicLong();
public long next() {
return value.incrementAndGet();
}
}next() 把读取、加一和写回合为一次原子更新,调用方无需在外部拆成 get() 和 set()。但这只是当前 Sequence 实例中的计数,不是跨进程的序列服务,也没有处理 long 溢出。
“单个状态”不一定只有一个字段。假设库存 stock 和已售数量 sold 必须一起变化,那么需要保护的是它们的组合约束,也称不变量:本例中,每次成功扣减都让库存减一、已售数量加一,二者之和保持不变。分别使用两个原子整数,不能让这两步自动成为一次整体更新。
下面是类成员和方法片段,需导入 AtomicReference,并把字段和 deduct() 放在所属类中。示例初始库存为 10,只展示扣减路径,所有更新都必须遵守同一协议:
java
final class State {
final int stock;
final int sold;
State(int stock, int sold) {
this.stock = stock;
this.sold = sold;
}
}
private final AtomicReference<State> state =
new AtomicReference<>(new State(10, 0));
public boolean deduct() {
while (true) {
State old = state.get();
if (old.stock == 0) return false;
State next = new State(old.stock - 1, old.sold + 1);
if (state.compareAndSet(old, next)) return true;
}
}State 的字段不可变,每次扣减都创建一个新对象,而不是修改读到的旧对象。AtomicReference 的 CAS 按引用身份比较:只有引用仍指向 old,才整体换成 next。因此读者看到的是一次更新前或更新后的完整状态,不会看到只修改了库存的半成品。
如果另一个线程已经替换状态,CAS 失败,循环会重新读取库存并计算。返回 true 表示本次扣减已提交;返回 false 表示本次读取的状态库存为零。这种写法适用于状态较小、更新逻辑短小的场景,失败重试仍会重新计算并创建对象。
3. ABA 问题
一个线程读到值 A,暂停期间另一个线程把值从 A 改为 B,又改回 A。前者恢复后,以 A 为期望值的 CAS 仍可成功。这就是 ABA:比较只能判断当前值是否相同,不能判断期间是否发生过变化。
如果算法根据旧值推断对象身份或链表结构“从未变化”,这种推断就可能失效。是否需要识别 ABA,取决于中间变化是否会使本次更新所依据的判断过期;普通计数器通常只关心当前数值。
下面是带版本号的引用更新片段,需导入 AtomicStampedReference。Node、initial 和 next 由具体算法定义;此处只展示 API,不是完整链表操作:
java
AtomicStampedReference<Node> head =
new AtomicStampedReference<>(initial, 0);
int[] stamp = new int[1];
Node current = head.get(stamp);
head.compareAndSet(current, next, stamp[0], stamp[0] + 1);stamp 是随引用一起比较和更新的版本号。get(stamp) 读取引用及其版本,compareAndSet 要求两者都符合预期才提交。即使引用回到原对象,只要版本不同,本次 CAS 就会失败。这个方案要求所有相关更新都推进版本,并考虑版本号回绕或复用;它不会自动记录完整历史。片段未处理失败分支,调用方必须检查返回值,再决定重试或退出。
4. AtomicLong 与 LongAdder
AtomicLong 维护一个线性化的单值,多个线程更新时竞争同一处状态。LongAdder 在竞争下将更新分散到多个 Cell(内部计数单元),读取 sum() 时再汇总,以减少更新集中在一点的竞争。下面是方法体片段,需导入 LongAdder:
java
LongAdder requests = new LongAdder();
requests.increment();
long snapshot = requests.sum();LongAdder 适合高并发统计,但并发更新可能发生在汇总不同计数单元之间,因此 sum() 不是与所有并发更新线性化的快照。示例变量虽然叫 snapshot,也不代表精确时点快照;是否比 AtomicLong 更快仍需在目标负载下测量。
需要基于当前值执行精确的条件更新时,应使用 CAS 等原子协议,不要用 LongAdder 代替 AtomicLong。同样,先调用 AtomicLong.get() 判断、再单独更新,也会留下并发窗口;原子读取不等于整个业务流程原子。
5. CAS 不是无成本
CAS 失败后,循环仍要读取、计算并尝试更新。竞争越激烈,失败重试越可能消耗 CPU,却没有提交更多有效更新。这种持续尝试而未成功的工作就是这里所说的“空转”。
长时间 CAS 循环需要考虑退避(失败后暂缓重试)、失败上限或改用锁。设定上限时,还要定义失败如何返回给调用方,不能直接把尚未完成的更新当作成功。
回调式更新函数也可能被执行多次:updateAndGet 在竞争失败后可能再次调用函数来计算新值。因此回调应只计算候选结果,不应发送消息、记账或执行其他不可重复的副作用。下面是错误用法片段,沿用第一节的 counter;sendMessage() 代表业务发送动作:
java
counter.updateAndGet(old -> {
sendMessage(); // 错误:CAS 失败时可能重复发送
return old + 1;
});5.1 活锁、饥饿和公平性
活锁指线程不断活动却没有有效推进;饥饿指某个线程长期得不到执行机会或无法完成操作。两者都可能表现为等待很久,但判断时要区分系统整体和单个线程的进展。
典型的 CAS 重试算法可以采用 lock-free(无锁)设计:系统整体能够持续推进,但不保证每个线程都在有限步数内成功。不能仅凭代码里有 CAS 就认定整个算法 lock-free,还要检查更新计算中是否有阻塞等操作。高竞争下,即使其他线程不断成功,某个线程也可能长期失败并消耗 CPU,这属于饥饿风险;无锁也不提供公平性保证。
因此需要同时评估:
- 单次更新的计算成本;
- 竞争失败率和重试次数;
- 对单线程尾延迟(少数慢操作的耗时)或公平性的要求;
- 是否可以分片、批量合并,或直接改用互斥锁。
6. VarHandle 与内存语义
前面解决的是“一次更新能否不可分割地生效”。实现底层组件时,还要考虑其他读写的可见性和先后约束,这些规则称为内存语义。
JDK 9+ 的 VarHandle 是访问字段、数组元素等变量的 API,提供 plain(普通访问)、opaque(不透明访问)、acquire/release(获取/释放)和 volatile(易失访问)等模式。它们对可见性与读写顺序的保证不同;这里仅介绍入口,不展开各模式的完整规则。不应在普通业务代码中为追求微小性能而随意放弱语义。
对多数业务代码:
- 优先使用
AtomicInteger/AtomicReference等高层 API; - 只在实现底层并发组件且能证明内存序,即相关读写的顺序约束时,才直接使用
VarHandle; - 使用 JCStress 并发正确性测试工具检查可能出现的结果,不仅在 x86 上运行普通单元测试;测试未观察到错误不能替代正确性论证。
7. 验证与观测
正确性测试检查结果是否满足并发契约,性能测试检查特定负载下的代价,两者不能互相替代。下表是验证建议,并非本文已执行的实验:
| 问题 | 工具 | 应观察的结果 |
|---|---|---|
| 操作是否符合 JMM | JCStress | 允许、可接受但特殊、禁止结果 |
| CAS 与锁谁更快 | JMH | 不同线程数下的吞吐、P99 和 CPU |
| 生产 CPU 过高 | JFR / async-profiler | 原子更新热点、重试循环与调用方 |
JMH 是 Java 微基准框架,JFR(Java Flight Recorder)和 async-profiler 用于运行观测与性能分析。吞吐表示单位时间完成的操作数,P99 表示 99% 的样本耗时不超过的值。延迟分位数和 CPU 指标需要相应的采样、分析配置;工具默认输出不一定覆盖这些指标。比较 CAS 与锁时,还应明确 JDK、硬件、线程数、更新逻辑和测量方法。
具体方法见 A - Java 并发代码测试方法;已经出现 CPU 异常时转到 14 - Java 进程 CPU 飙高排查。
8. 容易踩的坑
审查代码时,可以把前面的边界转成几个问题:
- 条件判断和更新是否处在同一个原子协议中,还是拆成了“先读、再写”?
- 需要一起变化的字段是否作为整体提交,还是仅分别使用原子变量?
- CAS 失败后是否重新读取并计算,重试逻辑是否包含不可重复副作用?
- 业务是否依赖中间变化历史,是否错误地把数值相同当成从未变化?
- 统计读数是否被当成精确业务条件,高竞争成本是否只凭低竞争测试推断?
9. 总结
CAS 把比较与更新合为一个原子操作;基于 CAS 的重试协议适合短小的单状态更新,不能自动保护复杂业务流程。
- 单变量更新可优先考虑原子类。
- 中间变化会使更新依据失效时,需要考虑用版本号等机制识别 ABA。
- 高竞争 CAS 会空转,性能结论必须实测。
后续阅读:22 - LongAdder、高竞争计数与伪共享深入计数热点;23 - ConcurrentLinkedQueue 与无锁队列展示 CAS 在队列中的应用;容器方向继续阅读 08 - ConcurrentHashMap 与并发容器。