跳到主要内容
约 8 分钟3 张卡

CAS

CAS(Compare And Set,比较并设置)是一次原子的条件更新:只有当前值等于预期值时,才写入新值,否则什么也不做并返回失败。Java 的原子类、ConcurrentHashMap 和 AQS 都建立在它上面。

CAS 本身很简单,难的是用对它。失败之后要重新读取再算一遍,更新函数里的副作用会跟着重复;只比较当前值,又看不出值在中间被改过又改回来(ABA)。弱 CAS 的失败条件和内存语义也和普通 CAS 不同。下文以 Java 17 和 21 为准。

1. 面试核心​

先记住这几条,再读正文
  • CAS 在当前值等于预期值时原子写入新值;失败后由调用方重新读取,并决定是否重试。
  • updateAndGet 在竞争后会重新调用更新函数,所以函数只应计算结果,不要执行外部动作。卡 · 重试函数与副作用
  • ABA 指状态从 A 变为 B 后又回到 A,只比较当前值的 CAS 发现不了中间的变化。卡 · ABA 问题
  • AtomicStampedReference 把引用和整数版本一起原子比较,每次变化都推进版本,才能检测到中间变化。
  • weakCompareAndSetPlain 即使值匹配也允许失败,并且只提供 plain 内存语义。卡 · 弱 CAS 与内存语义

2. CAS 的条件更新​

CAS 把「检查」和「写入」合成一个原子操作,失败了就重新检查。以余额扣减为例,它要同时满足两个条件:余额足够,并且扣减依据的余额仍是当前值。

AtomicInteger balance = new AtomicInteger(100);

boolean withdraw(int amount) {
while (true) {
int current = balance.get();
if (current < amount) {
return false;
}
if (balance.compareAndSet(current, current - amount)) {
return true;
}
}
}

本例假设 amount > 0,初始余额非负。循环先读取余额 current,不够就返回 false。余额够的话,compareAndSet 检查余额是否仍然是 current,是才写入扣减后的值。

假设两个线程同时扣 80:两个线程都读到 100,第一个线程的 CAS 把 100 改成 20 并成功;第二个线程的 CAS 期望 100,实际是 20,于是失败。它回到循环开头重新读取,发现 20 不够 80,返回 false。如果不重新检查,而是直接再扣一次,余额就会变成负数。

成功的那次 CAS 就是这次扣减生效的时刻,这个时刻称为线性化点。强 CAS 失败只说明比较时的值和预期不同,所以失败后必须重新读取、重新判断。

CAS 一次只管一个变量。多个变量分别 CAS 时,各次更新独立生效,不会自动组成事务。多个字段要共同满足业务约束时,可以把它们放进不可变对象,再原子替换整个引用,做法见 Java 原子类。

3. 重试函数与副作用​

updateAndGet、accumulateAndGet 这类方法内部也是 CAS 循环:CAS 失败后,会用新读到的值再调用一次你传进去的函数。所以放在函数里的外部动作,也会跟着重复执行:

value.updateAndGet(current -> {
auditClient.send(current); // 不安全:函数可能执行多次
return current + 1;
});

竞争激烈时,这个函数可能在一次更新里被调用好几次,auditClient.send 就会重复发送审计请求。写日志、实际扣款、发网络请求,这些会改变外部状态的副作用都有同样的问题。更新函数只应根据输入计算新值,副作用放到 CAS 成功之后再做。

挪到 CAS 之后也不是万事大吉,两步之间仍可能失败,见原子更新与外部动作。

4. ABA 问题​

ABA 是指值从 A 变成 B,又变回 A。CAS 只比较当前值,看到的还是 A,就会成功,中间发生过的变化被藏起来了。线程交错过程如下:

  1. 线程甲读取引用 A,根据 A 算好待更新的值,然后暂停。
  2. 线程乙把 A 换成 B,又把同一个 A 放了回来。
  3. 线程甲恢复执行,CAS 比较当前引用,发现还是 A,于是成功。

这会不会出错,要看线程甲算出来的值是否依赖 A 当时的状态。以无锁栈为例:栈是 A → B → C,线程甲准备出栈,读到栈顶 A 和它的后继 B,打算把栈顶 CAS 成 B。暂停期间,线程乙弹出了 A 和 B,又把 A 重新压回去,栈变成 A → C。线程甲恢复后,CAS 发现栈顶还是 A,成功把栈顶改成了 B,而 B 早就不在栈里了,链表结构被破坏。

反过来,普通计数器从 10 变到 11 再回到 10,如果算法只关心当前数值,这种变化无所谓。所以是否需要处理 ABA,要看节点被移除、复用这些历史会不会影响算法的判断。

5. 版本号与 AtomicStampedReference​

要发现中间的变化,就把版本号和值一起比较。AtomicStampedReference 给引用附带一个整数版本,每次 CAS 同时检查引用和版本:

AtomicStampedReference<Node> head =
new AtomicStampedReference<>(initial, 0);

int[] stamp = new int[1];
Node current = head.get(stamp);
boolean updated = head.compareAndSet(
current,
current.next(),
stamp[0],
stamp[0] + 1
);

本例假设 current 非空,读取节点的 next 是安全的。get(stamp) 同时读出引用和版本,版本写进数组 stamp。compareAndSet 原子比较两者,成功时把引用换成后继节点,并把版本加一。回到上一节的例子:线程乙每次修改都推进了版本,线程甲手里的旧版本对不上,CAS 就会失败。

版本标记也有边界:

  • 每次状态变化都必须推进版本。业务自己维护版本号时,也要把版本和值放在同一次原子更新里。
  • 整数版本溢出后会回绕,也就是再次出现用过的数值。旧引用和旧版本恰好同时再出现时,这次比较仍然发现不了变化。
  • 版本号只负责检测变化。节点复用和内存回收是否安全,仍要按具体数据结构逐种分析线程交错。

对于因为复用同一个节点产生的 ABA,还可以从源头入手:限制节点复用,或者采用适合该算法的内存回收协议。

如果只需要记录节点是否被逻辑删除,可以用 AtomicMarkableReference。它携带的是一个布尔标记,适合表达「已删除」,但不能像持续递增的版本号那样记录变化了几次。

6. CAS 的进度保证​

CAS 失败的线程可以立刻重试,不用等别人释放锁;但这不保证每个线程都能及时完成。高竞争下,可能其他线程不断成功,某一个线程却一直失败。系统整体有进展和每个线程都能完成,是两种不同的保证。

lock-free 表示系统整体能持续取得进展,wait-free 则要求每个操作都在有限步内完成。一个算法具备哪种保证,要看完整算法,不能只看它用没用 CAS,具体区别见 锁与无锁。

竞争明显时,可以用退避减少密集重试,也就是失败后稍等一会儿再试;也可以考虑分片、批处理或者干脆用锁。这些做法的收益都要用基准测试和运行时采样验证,分片与批处理怎样降低共享竞争见 锁与无锁。

7. 弱 CAS 与内存语义​

CAS 方法之间有两个区别:失败条件,以及内存可见性。

强 compareAndSet 只有在值不匹配时才失败,并且具有 volatile 读写的内存语义。volatile 语义的作用是在线程之间建立可见性和顺序约束:CAS 之前写入的普通字段,其他线程读到 CAS 结果后也能看到。

弱 CAS 允许虚假失败,也就是值明明匹配,仍然返回 false。这让 JVM 可以在某些处理器上使用更便宜的指令。调用方要按算法要求处理这种失败,通常是放在循环里重试。

weakCompareAndSetPlain 还只提供 plain 内存语义。plain 就是普通读写的内存访问模式,这个操作的原子性只覆盖目标变量本身,不负责让其他字段对别的线程可见。如果要让其他线程看到之前写入的普通字段,还要另外建立发布关系,比如改用 volatile 语义的 CAS。

Java 17 和 21 的原子类提供按内存模式命名的弱 CAS 方法,比如 weakCompareAndSetPlain、weakCompareAndSetVolatile。旧的 weakCompareAndSet 实际是 plain 语义,名字却容易让人以为是 volatile 语义,所以已经弃用。可见性与发布关系见 Java 内存模型。

8. 原子更新与外部动作​

把副作用挪到 CAS 成功之后,能避免重算时重复执行,但 CAS 和外部动作仍是两步,中间可能失败。比如 CAS 更新状态后再发消息:进程在发送前崩溃,消息就丢了;发送后没收到确认,调用方重试,又会重复发送。

内存里的 CAS 只能保证被更新的那个状态是原子的。业务要求状态和消息一起提交时,需要额外的一致性协议。常见做法是在同一个持久化事务里更新业务状态,并记录一条待发送事件,再由后台重试投递。消费方按事件标识去重,让重复投递只产生一次业务效果,这称为幂等处理。

9. 常见问题​

9.1 CAS 和乐观锁是一回事吗?​

不完全是。CAS 是执行原子条件更新的基础操作,常用来实现乐观并发控制:先读取并计算,提交时再检查状态是否还和预期一致。CAS 可以承担提交时的检查和更新,但一个完整的算法还要定义失败后怎样重试、什么时候放弃,以及能提供什么进度保证。

9.2 AtomicReference 的 CAS 比较的是对象内容吗?​

10. 面试题卡片​

11. 参考资料​

来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明