Skip to content

2.4-5 CAS、ABA、Atomic 家族与 LongAdder ​

所属:02 Java 运行时 / 2.4 并发 分级:B(按 A 类模板展开) 状态:◐ 初稿 关联:2.2-2、2.4-1、2.4-3、2.4-6、2.4-10

  • 题型:原理 / 对比

  • 一句话结论:CAS 是 CPU 提供的“比较并交换”原子指令,Java 通过 Unsafe/VarHandle 暴露;Atomic 家族用 volatile 值 + CAS 循环实现无锁原子更新,ABA 靠版本戳/标记解决;LongAdder 用 base + Cell 分散热点,牺牲 sum() 的强一致快照换高并发吞吐,适合统计计数而不是精确序列。

  • 分层要点:

    1. CAS 的本质:CAS(V, A, B) 表示“如果内存位置 V 的当前值等于预期值 A,就原子地改成 B,否则失败”。它由 CPU 原子指令实现(x86 通常是 LOCK CMPXCHG,ARM 用 LL/SC 或 CAS 指令),Java 里由 Unsafe.compareAndSwapInt/Long/Object、VarHandle.compareAndSet 暴露。CAS 自带 volatile 读写语义,成功时能建立可见性;它通常配合循环重试,属于 lock-free,但不是 wait-free,竞争激烈时可能一直自旋。
    2. ABA 问题:线程 1 读到值 A,线程 2 把 A 改成 B 又改回 A,线程 1 的 CAS 仍然成功,但它不知道中间发生过变化。对“只看最终数值”的计数可能无害,对链表/栈/对象状态可能致命:例如栈顶 A 被弹出、B 被弹出、A 又被压回,CAS 把栈顶改成 B 会复活已弹出的节点。解决方案是给引用配版本:AtomicStampedReference 用 int stamp,AtomicMarkableReference 用 boolean 标记(只能区分两种状态,不能替代完整版本);也可以把状态做成不可变对象整体 CAS,或者直接加锁。stamp 会回绕,极长时间/极高并发下要评估。
    3. Atomic 家族与实现:AtomicInteger/AtomicLong/AtomicBoolean/AtomicReference 内部是 volatile 值和字段偏移量,compareAndSet 调 Unsafe.compareAndSwapXxx,getAndIncrement 等是 CAS 循环。数组类 AtomicIntegerArray/AtomicLongArray/AtomicReferenceArray 对元素做 CAS;AtomicStampedReference/AtomicMarkableReference 解决 ABA;AtomicIntegerFieldUpdater 等用反射拿偏移量,要求字段 volatile 且可访问。常用方法有 getAndSet、getAndAdd、updateAndGet、accumulateAndGet、lazySet、weakCompareAndSet。
    4. 内存语义与弱化操作:get/set 有 volatile 语义;lazySet 是弱化写,最终可见但不保证立刻被其他线程看到,适合“先写普通字段,最后 lazySet 发布引用”的场景;weakCompareAndSet 允许虚假失败、语义更弱,必须放在循环里,JDK 9+ 可用 VarHandle 的 plain/acquire/release/volatile 模式表达更精确的语义。compareAndSet 比较的是引用身份,不是 equals;AtomicReference 更新可变对象时要特别小心。
    5. LongAdder 与 Striped64:LongAdder 内部是 base + Cell[],Cell 用 @Contended 填充缓存行。低竞争时 CAS base;竞争时按线程 probe 落到不同 Cell 上 CAS,减少同一缓存行的争用;sum() 遍历 base + 所有 Cell,因此不是原子快照,并发更新时可能少算/多算。LongAccumulator 用同样的分散结构支持自定义聚合函数,DoubleAdder 处理 double,但浮点不满足结合律,求和顺序不确定。reset()/sumThenReset() 也不是原子操作,只适合在无并发更新时使用。
    6. Unsafe 与工程边界:Unsafe 提供字段偏移、CAS、ordered write、内存屏障、park/unpark 等底层能力,Atomic/AQS/ConcurrentHashMap 都在用;但它是内部 API,JDK 9+ 优先 VarHandle,JDK 17+ 模块封装更强,业务代码不应直接依赖。CAS 适合单变量状态、计数器、无锁栈/队列;多变量可用不可变对象整体 CAS,否则复杂临界区、需要阻塞/条件等待时还是锁更合适。
  • 图/流程:

text
CAS(V, A, B)
  ├─ V == A → V = B,返回 true
  └─ V != A → 返回 false,通常循环重试

AtomicInteger.getAndIncrement()
  └─ Unsafe.getAndAddInt
       do {
         old = getIntVolatile(valueOffset);
       } while (!compareAndSwapInt(valueOffset, old, old + 1));
       return old;
text
LongAdder.add(x)
  ├─ CAS base 成功 → 结束
  └─ 失败 → 按线程 probe 选 Cell
         ├─ Cell 为空 → CAS 安装
         ├─ Cell CAS 成功 → 结束
         └─ 冲突 → longAccumulate 扩容/换槽

sum() = base + Σ cells   // 弱一致快照,不是原子读
  • 版本/源码锚点:

    • JDK 5+:java.util.concurrent.atomic、Unsafe CAS。
    • JDK 8+:LongAdder、LongAccumulator、Striped64、@Contended。
    • JDK 9+:VarHandle 提供显式内存访问模式;Thread.onSpinWait() 自旋提示。
    • JDK 17+:模块封装加强,业务代码不要直接依赖 sun.misc.Unsafe。
  • Atomic 家族表:

类用途关键点
AtomicInteger/Long单变量原子增减、CASvolatile 值 + Unsafe 偏移
AtomicBoolean状态标志本质是 int 0/1
AtomicReference原子替换引用CAS 比较引用身份,不是 equals
AtomicIntegerArray/LongArray数组元素原子更新元素不是 volatile,靠 CAS
AtomicStampedReference带版本戳的引用解决 ABA
AtomicMarkableReference带 boolean 标记的引用只能区分两种标记
AtomicIntegerFieldUpdater给现有 volatile 字段做原子更新省对象开销,字段必须 volatile
LongAdder/DoubleAdder高并发统计计数分散 Cell,sum 弱一致
LongAccumulator自定义聚合函数需结合律/交换律
  • AtomicLong vs LongAdder:
维度AtomicLongLongAdder
精确快照get() 强一致sum() 弱一致
CAS/序列支持 compareAndSet、getAndIncrement不支持逐值 CAS
高并发写单点 CAS,缓存行争用分散到 Cell,吞吐高
内存小更大(Cell 数组)
适用ID、序列、状态QPS、计数、指标
  • 追问链:

    1. CAS 是什么?Java 怎么用? → CPU 的原子比较交换指令;Java 通过 Unsafe.compareAndSwapInt/Long/Object 或 VarHandle.compareAndSet 调用,Atomic 类和 AQS 都建立在它上面。
    2. CAS 有什么缺点? → ABA、只能保证一个变量、竞争激烈时自旋浪费 CPU、需要处理失败重试;复杂临界区还是锁更合适。
    3. ABA 是怎么发生的? → 值从 A 变成 B 又变回 A,CAS 只比较当前值,发现仍是 A 就成功,无法感知中间变化;链表/栈的节点复活是典型危害。
    4. 怎么解决 ABA? → AtomicStampedReference 加版本戳、AtomicMarkableReference 加标记、不可变对象整体 CAS,或者加锁;stamp 也会回绕,极端场景要评估。
    5. AtomicInteger 怎么实现原子自增? → volatile int value + 字段偏移量;getAndIncrement 调 Unsafe.getAndAddInt,内部 CAS 循环直到成功,返回旧值。
    6. lazySet 和普通 set 有什么区别? → set 是 volatile 写,立即可见;lazySet 是弱化写,最终可见,减少屏障开销,适合发布前的最后一步,不能当成立即 handoff。
    7. weakCompareAndSet 和 compareAndSet 有什么区别? → weak 版本允许虚假失败、内存语义更弱,必须循环重试;强 CAS 不会虚假失败。JDK 9+ 可用 VarHandle 明确 acquire/release/volatile 语义。
    8. AtomicReference 的 CAS 比较的是什么? → 引用身份(==),不是 equals;两个内容相等的不同对象,CAS 会失败。
    9. LongAdder 为什么高并发下快? → 把热点拆到多个 Cell,每个线程在自己的槽上 CAS,减少同一缓存行争用;代价是 sum 不是原子快照、内存更大。
    10. LongAdder 的 sum 为什么不是强一致? → sum 要逐个读 base 和 Cell,读的过程中其他线程还在更新,得到的是近似值;需要精确值用 AtomicLong 或加锁。
    11. LongAdder 能替代 AtomicLong 吗? → 不能;LongAdder 没有逐值 CAS、没有精确 get,适合统计计数;ID/序列/状态机用 AtomicLong。
    12. LongAdder 的 reset 有什么坑? → reset/sumThenReset 不是原子操作,并发更新时可能丢失增量;只应在无并发写入时使用,监控场景更推荐单调计数 + 计算差值。
    13. Unsafe 在 JDK 9+ 怎么替代? → 用 VarHandle 做字段/数组的原子访问和内存模式控制;JDK 17+ 模块封装加强,业务代码不要直接依赖 Unsafe。
    14. CAS 在 AQS/ConcurrentHashMap 里用在哪? → AQS 用 CAS 改 state、抢 tail;CHM 用 CAS 插入桶、改 sizeCtl,并用 baseCount + CounterCell 分散计数,思路和 LongAdder 类似。
    15. 自旋 CAS 太耗 CPU 怎么办? → 降低竞争、分段/分槽、退避、Thread.onSpinWait(),或者改用锁/阻塞队列;不要在高竞争长临界区里裸写 CAS 循环。
  • 生产案例/取舍(示例,替换成你的项目):

    • 接口 QPS 统计用 AtomicLong,高并发下 CAS 热点明显,TP99 抖动;换成 LongAdder 后吞吐提升,但监控抓取 sum() 是近似值,业务可接受。
    • 订单号/序列号必须严格递增且不能重复,继续用 AtomicLong 或数据库号段,不能用 LongAdder 的弱一致 sum 代替。
    • 无锁栈用 AtomicReference 做 CAS,压测出现节点丢失;原因是 ABA,换成 AtomicStampedReference 或在 CAS 前校验版本后恢复。
    • 用 AtomicReference 更新可变配置对象,CAS 成功后其他线程仍可能看到对象内部字段变化;改成不可变对象整体替换,或加锁/快照。
    • LongAdder.reset() 在监控采集时调用,采集瞬间的并发增量被清掉;改成单调计数 + 两次采样求差,避免丢量。
    • 取舍:CAS 适合单变量、短临界区、低到中等竞争;高竞争计数用 LongAdder;复杂状态/多变量一致性用锁。
  • 易错点:

    • 认为 CAS 能保证多个变量的原子性。
    • 认为 CAS 一定无锁就一定快;高竞争自旋会烧 CPU。
    • 忽略 ABA,或认为所有 ABA 都无害。
    • 认为 AtomicReference.compareAndSet 比较的是 equals。
    • 把 lazySet 当成立即可见,做完就指望其他线程马上读到。
    • 认为 LongAdder.sum() 是精确快照。
    • 用 LongAdder 做 ID/序列/需要 CAS 的状态机。
    • 在并发更新时调用 LongAdder.reset()/sumThenReset()。
    • AtomicIntegerFieldUpdater 的字段不是 volatile、是 static,或不可访问。
    • 业务代码直接依赖 sun.misc.Unsafe,升级 JDK 后崩溃。
    • DoubleAdder 用于金额等需要精确、可复现求和的场景。
  • 30 秒口述稿:

CAS 是 CPU 的比较并交换指令,Java 通过 Unsafe 或 VarHandle 调用;Atomic 家族用 volatile 值加 CAS 循环实现无锁更新,优点是单变量原子、无阻塞,缺点是 ABA、自旋和多变量限制。ABA 用 AtomicStampedReference 的版本戳或 AtomicMarkableReference 的标记解决。LongAdder 用 base 加 Cell 分散热点,高并发计数吞吐高,但 sum 是弱一致快照、不能替代 AtomicLong 的精确序列。简单状态用 Atomic,复杂临界区用锁。

  • 3 分钟展开顺序:结论(CAS 指令 + Atomic + LongAdder)→ CAS 硬件/JMM 语义 → ABA 与版本戳 → Atomic 家族与实现 → lazySet/weak CAS → LongAdder/Striped64 分散热点 → AtomicLong vs LongAdder → Unsafe/VarHandle 边界 → 生产坑与选型。