上一节说 volatile 管不了 count++ 的原子性,留了个尾巴:AtomicInteger 为什么就行?靠的是 CAS——整个 JUC 大厦的地基,线程池、锁、并发容器全站在它上面。
CAS(Compare And Swap,比较并交换)是一条 CPU 原子指令(x86 的 cmpxchg),逻辑就一句话:
我看这个值还是 A 吗?是就换成 B;不是就算了,告诉我失败。
占座类比:离开座位时放个书包(值=A),回来先看书包还是不是你那个——是,坐下(换成 B);被人挪了,重新商量(失败重试)。全程不需要管理员(不用加锁),所以叫乐观锁:先假设没人捣乱,动手时才验证。
而 synchronized 那套是悲观锁:进门先上锁,默认一定有人抢。乐观还是悲观,取决于竞争烈度——人少占座快,人多排队快。
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(超高并发计数,分段累加最后求和,把一个热点的争用拆到多个槽位)。
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(一个布尔标记)更省。
1. 自旋烧 CPU:竞争激烈时反复失败重试,空转烧核;高并发计数改用 LongAdder
2. 一次只能保一个变量:多个变量的原子性 CAS 无能为力,只能上锁或封装成一个对象再用 AtomicReference
3. ABA:如上,版本号伺候
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<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 再看 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 started = new AtomicBoolean(false);
if (started.compareAndSet(false, true)) { // 只有第一个线程成功
init(); // 初始化只跑一次
}
compareAndSet 的返回值本身就是信息:成没成一步到位,比「先 get 再 if」的两步写法原子得多。同类舞台:熔断开关的首次跳闸、任务去重触发、优雅关闭标记——凡「第一次说了算」的逻辑都归它管。
再辨析一下和 synchronized 做初始化的差别:锁版每个线程都要排队过一道门;CAS 版失败者直接跳过不等,天然适合「一人干活、众人放行」。但若失败者必须等结果(要用 init 的产物),就得换 Future 或 CountDownLatch 让大家真等。最后一个习惯:用 Atomic 类先想清楚「失败了怎么办」——自旋重试、放弃、还是记日志,三条路里选一条,别默认它永远成功。把这句话放进代码评审清单,能拦下大半 CAS 滥用。
get() 和 compareAndSet() 分开写仍可能插队,要用 getAndAccumulate、updateAndGet 这类一体化方法CAS 是「值还是我记的那个就换」的 CPU 原子指令,失败自旋重试,撑起 Atomic 家族;软肋是自旋开销和 ABA,后者用版本号治。