← 课程目录 🚀 从零到一
📐 学习维度 阶段2 · 第7章 并发编程 🚀 从零到一 📚 课程目录 🏠 首页 🛤️ 学习路径

7.4 CAS 与原子类:乐观锁的底层引擎

审校 2026-09-26 · 素材来源:L04-volatile与CAS与Java内存模型(底稿改写)
📑 本篇章节导航 (共12节,点击直达)
CAS:占座放书包AtomicInteger 为什么快ABA:值一样的陷阱CAS 的三个代价LongAdder:把一个柜台拆成一排AtomicReference:给任意对象上 CASCAS 都藏在哪老代码常见:字段原子更新器加餐:AtomicBoolean 做一次性开关踩坑清单面试怎么问一句话总结

上一节说 volatile 管不了 count++ 的原子性,留了个尾巴:AtomicInteger 为什么就行?靠的是 CAS——整个 JUC 大厦的地基,线程池、锁、并发容器全站在它上面。

CAS:占座放书包

CAS(Compare And Swap,比较并交换)是一条 CPU 原子指令(x86 的 cmpxchg),逻辑就一句话:

我看这个值还是 A 吗?是就换成 B;不是就算了,告诉我失败。

占座类比:离开座位时放个书包(值=A),回来先看书包还是不是你那个——是,坐下(换成 B);被人挪了,重新商量(失败重试)。全程不需要管理员(不用加锁),所以叫乐观锁:先假设没人捣乱,动手时才验证。

而 synchronized 那套是悲观锁:进门先上锁,默认一定有人抢。乐观还是悲观,取决于竞争烈度——人少占座快,人多排队快。

AtomicInteger 为什么快

count++ 三步被打断会丢更新。AtomicInteger 的做法是「失败就重试」的自旋 CAS:


AtomicInteger count = new AtomicInteger(0);

public void add() {
    count.incrementAndGet(); // 原子自增,内部就是自旋 CAS
}

// incrementAndGet 的灵魂逻辑(简化)
do {
    v = 读最新值;                    // ① 拿旧值
} while (!cas(v, v + 1));            // ② 期望是 v 就换成 v+1;被人抢先了就重来

线程 A、B 同时读到 5:A 先 CAS(5→6) 成功;B 的 CAS(5→6) 发现当前已是 6,失败,重读再试成 7。不丢账、不阻塞、不用切内核态——这就是「Atomic 比 synchronized 计数快」的原因。

原子家族按需取用:AtomicLong(长整数)、AtomicReference(任意对象)、AtomicIntegerArray(数组)、LongAdder(超高并发计数,分段累加最后求和,把一个热点的争用拆到多个槽位)。

ABA:值一样的陷阱

CAS 只认「值」,不认「经历」:值从 A 改成 B 又改回 A,CAS 一看是 A,放行——但它中间被动过了。

还用占座说:你放的书包被人拿走、扔了、又买了个一模一样的放回来。你 CAS 检查「书包还是那个款」,坐下了,但里面装的东西早换了。

多数场景无所谓(纯计数不在乎经历),但链表、栈这类结构会坏:线程 1 记下 head=A、next=B;线程 2 把 A、B 都弹了又把 A 压回去;线程 1 CAS(head A→B) 成功,可 B 已被移除——链表指向了尸体。

解法是给值配版本号:


// 每次改动版本 +1:A(1) → B(2) → A(3)
AtomicStampedReference<String> ref =
        new AtomicStampedReference<>("A", 1);   // 值 + 版本戳

int stamp = ref.getStamp();                     // 记下当前版本
ref.compareAndSet("A", "B", stamp, stamp + 1);  // 值和版本都要对上才换

// 之后再 A→?:值是 A 但版本已是 3,期望 1 的 CAS 失败 → 骗不了了

只要知道「动没动过」不需要次数的,用 AtomicMarkableReference(一个布尔标记)更省。

CAS 的三个代价

1. 自旋烧 CPU:竞争激烈时反复失败重试,空转烧核;高并发计数改用 LongAdder

2. 一次只能保一个变量:多个变量的原子性 CAS 无能为力,只能上锁或封装成一个对象再用 AtomicReference

3. ABA:如上,版本号伺候

LongAdder:把一个柜台拆成一排

AtomicInteger 再快,高并发下所有线程还是挤一个变量 CAS,失败率随线程数飙升。LongAdder 的思路是「化整为零」:


AtomicInteger:  100 个线程抢 1 个柜台
LongAdder:      base 值 + Cell[0] Cell[1] ... Cell[n]
                挤就各自去不同的 Cell 加,sum() 时再求和

写的时候先试 base,CAS 失败就按线程哈希散到某个 Cell 上各加各的——争用被摊薄。sum() 把 base 和所有 Cell 加总返回。代价和 ConcurrentHashMap 的 size() 一样:求和是弱一致快照。选型口诀:低中并发用 Atomic(读多写少还要频繁读精确值),超高并发纯累加(统计计数、监控打点)用 LongAdder。

AtomicReference:给任意对象上 CAS

基本类型之外,任何对象也能享受原子更新:


AtomicReference<Order> current = new AtomicReference<>(new Order("待支付"));

public void pay() {
    Order old = current.get();
    Order paid = old.toPaid();                 // 生成已支付的新对象(不可变风格)
    current.compareAndSet(old, paid);          // 期间被别人改过就失败,业务层决定重试
}

配合不可变对象(每次改动生成新实例),旧值被改过 CAS 自然失败——不用锁也能实现「检查-修改」的原子语义。JDK 9+ 还有更现代的 VarHandle,思路相同,不再依赖 Unsafe 的黑魔法。

CAS 都藏在哪

学完 CAS 再看 JDK,满地都是它:

认出套路,读并发源码突然顺畅:凡见「自旋 + CAS + 失败重来」就是乐观锁的固定写法,剩下的问题只是它操作的账本是哪个变量。

这套思想不止 JVM。数据库乐观锁常用 version 字段:UPDATE 带 WHERE version = 旧值,影响行数为 0 说明被人改过,业务层重试——和 CAS「期望不符就失败」一模一样,只是从 CPU 指令换成了 SQL。

老代码常见:字段原子更新器

想原子更新普通字段,又不能改字段类型(比如实体要映射表结构),用 AtomicIntegerFieldUpdater:


AtomicIntegerFieldUpdater<User> cnt =
        AtomicIntegerFieldUpdater.newUpdater(User.class, "retryCount");

cnt.incrementAndGet(user);  // 等价 user.retryCount++,但是原子

限制三条:字段必须是 int、volatile、非 static,缺一条运行时直接抛异常。JDK 9+ 的现代替代是 VarHandle:不用反射、JIT 能内联优化,官方指定的接班人。顺带一个硬区别答面试:volatile 是关键字,只修饰字段、无原子语义;Atomic 是类,把 volatile 值加 CAS 自旋打包成了方法。

加餐:AtomicBoolean 做一次性开关

最被低估的用法是「只允许发生一次」:


AtomicBoolean started = new AtomicBoolean(false);

if (started.compareAndSet(false, true)) {  // 只有第一个线程成功
    init();                                 // 初始化只跑一次
}

compareAndSet 的返回值本身就是信息:成没成一步到位,比「先 get 再 if」的两步写法原子得多。同类舞台:熔断开关的首次跳闸、任务去重触发、优雅关闭标记——凡「第一次说了算」的逻辑都归它管。

再辨析一下和 synchronized 做初始化的差别:锁版每个线程都要排队过一道门;CAS 版失败者直接跳过不等,天然适合「一人干活、众人放行」。但若失败者必须等结果(要用 init 的产物),就得换 Future 或 CountDownLatch 让大家真等。最后一个习惯:用 Atomic 类先想清楚「失败了怎么办」——自旋重试、放弃、还是记日志,三条路里选一条,别默认它永远成功。把这句话放进代码评审清单,能拦下大半 CAS 滥用。

踩坑清单

面试怎么问

一句话总结

CAS 是「值还是我记的那个就换」的 CPU 原子指令,失败自旋重试,撑起 Atomic 家族;软肋是自旋开销和 ABA,后者用版本号治。