知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# CAS 与原子类详解 > 导读:本文从"不加锁也能保证线程安全吗"这个问题出发,把 CAS 的三个操作数、CPU 指令支撑、自旋重试流程讲清楚,重点补上 ABA 问题的产生场景与两种解决方案,最后落到原子类家族与生产选型。适合想搞懂 JUC 无锁并发、以及正在准备后端面试的同学。 ## 一、先建立全局认知 ### Q:什么是 CAS?它的三个操作数分别是什么? A:结论先行——CAS(Compare And Swap,比较并交换)是一种**乐观并发**的原子操作:先假设没有冲突,如果真的被改过就重试,而不是先把别人挡住。 它需要三个操作数: - **V(内存值)**:共享变量所在内存中当前的值; - **A(预期旧值)**:线程读到的、它认为"现在应该是多少"的那个值; - **B(新值)**:如果内存值确实等于 A,就把它更新为 B。 语义只有一句话:**当且仅当内存值 V 等于预期值 A 时,才把 V 更新为 B,否则什么都不做并返回失败**。整个"比较 + 交换"是不可分割的原子操作,中间不会被其他线程插入。 ### Q:为什么 CAS 能避免加锁的阻塞与上下文切换? A:加锁(如 `synchronized`)是**悲观**的:进临界区前先假定会冲突,于是抢锁。抢不到就阻塞挂起,从用户态陷入内核态;等锁释放被唤醒,再从内核态切回用户态。一来一回是两次**上下文切换**,纯属开销,和业务逻辑无关。 CAS 走的是另一条路:**不阻塞、不挂起**,失败就在原地自旋重试,线程始终在用户态运行。所以: 1. 没有线程挂起和唤醒,省掉了上下文切换的成本; 2. 不存在死锁——因为根本没有"持有并等待"的锁; 3. 它是 **lock-free(无锁)** 并发的基础,也是这类算法的地基。 代价后文会讲:自旋不是免费的,竞争激烈时会空转烧 CPU。准确说法是——CAS **用自旋换取阻塞**,不是白吃。 ## 二、理解核心机制 ### Q:Java 里 CAS 的入口在哪里?底层靠什么指令? A:Java 不直接暴露 CAS,而是分散在几个入口: - **`sun.misc.Unsafe`**:`compareAndSwapInt`、`compareAndSwapLong`、`compareAndSwapObject`,是 JDK 8 里 `AtomicInteger` 等原子类的底层依赖; - **`VarHandle`**(JDK 9 引入):提供 `compareAndSet` 等标准化的内存访问方法,官方推荐用来替代 `Unsafe`,因为它支持不同的内存访问语义,且不受模块化限制; - **原子类**:`AtomicInteger.compareAndSet(expected, update)` 这类方法,只是对上面入口的封装。 以 `Unsafe.compareAndSwapInt` 为例,它是 `native` 方法,最终映射到 CPU 的 **`cmpxchg`**(compare and exchange)指令。但光有 `cmpxchg` 还不够——在**多核**环境下,它本身不保证写入立刻对其他核可见,所以 HotSpot 会在这条指令前加 **`lock` 前缀**。`lock` 前缀做两件事: 1. 把当前处理器缓存行的数据**立即写回主内存**; 2. 通过**缓存一致性协议(如 MESI)**使其他处理器里该缓存行的副本失效,迫使它们重新从主内存读取。 这两件事合起来,就是"**一条指令同时实现原子性与可见性**"的原因,也是 CAS 能替代 volatile 写加锁的关键。  *图:CAS 的"读取—比较—交换"自旋流程,以及值从 A 变 B 再变回 A 时 ABA 问题如何绕过比较、用版本号如何解决。* ### Q:CAS 的自旋重试流程是怎样的? A:原子类里的 `getAndIncrement`、`addAndGet` 这类方法,本质都是一个自旋循环。用伪代码表示: ```text 循环 { old = 读取内存值 V // 当前值 new = old + 1 // 基于旧值算出新值 if (CAS(V, old, new)) { // 内存值仍等于 old 才写入 return old // 成功,退出循环 } // 失败:说明期间被别人改过,回到循环开头重新读取 } ``` 关键点:**失败不能拿旧值原地重试**,必须回到开头重新读取——值已经变了,再用旧的 `old` 去 CAS 只会一直失败。这就是"自旋":循环读取、计算、尝试,直到成功。 ### Q:CAS 有哪三大问题? A:总结成三条: 1. **ABA 问题**:值从 A 改成 B 又改回 A,CAS 只比较"值相不相等",会误判成"从没被改过"。典型后果是无锁链表节点状态丢失。解决办法是加**版本号**(`AtomicStampedReference`)或**布尔标记**(`AtomicMarkableReference`)。 2. **自旋开销**:竞争激烈时大量线程反复 CAS 失败、长时间空转,白烧 CPU;严重时还会争抢同一条缓存行,性能反而不如加锁。JDK 的对策之一就是让 `LongAdder` 用分段减少热点。 3. **只能保证单个变量的原子性**:CAS 一次只针对一个变量。如果操作是"先判断再更新"这类**复合操作**,比如两个变量要一起变、或读出来判断完再写回去,直接用原子类拼是不安全的,必须用 `compareAndSet` 循环把判断与更新包成一个原子块。 ## 三、放进真实场景 ### Q:AtomicInteger 自增和 synchronized 自增,差别到底在哪? A:两者都能保证自增线程安全,但思路相反——一个用 CAS 乐观重试,一个用锁悲观互斥。 ```java import java.util.concurrent.atomic.AtomicInteger; public class IncCompare { // 方案一:synchronized 悲观互斥 private int syncCount = 0; public synchronized void incBySync() { syncCount++; // 加锁、改值、解锁 } // 方案二:AtomicInteger 乐观 CAS private final AtomicInteger atomicCount = new AtomicInteger(); public void incByAtomic() { atomicCount.incrementAndGet(); // 底层是 CAS 自旋,无锁 } } ``` 关键点:`syncCount++` 看着是一行,实际是"读—加—写"三步,多线程下会丢更新,必须整段加锁;`incrementAndGet()` 内部把这三步包进 CAS 自旋,用一条指令保证原子性,因此更轻。低竞争时原子类没有加锁与唤醒开销,通常更快;但竞争激烈时它靠自旋,反而可能不如让线程排队。 ### Q:ABA 问题的产生场景是什么?怎么解决? A:先看最直观的复现。下面这段代码里,线程 T1 读到值为 100,准备改成 101;在这之前,线程 T2 把 100 改成 0、又改回 100。T1 的 CAS 会觉得"值还是 100,没被改过",于是照常成功——但我们其实丢掉了中间被改成 0 的历史。 ```java import java.util.concurrent.atomic.AtomicInteger; public class AbaProblem { public static void main(String[] args) throws InterruptedException { AtomicInteger value = new AtomicInteger(100); // T1:读到 100,先睡一会再去 CAS Thread t1 = new Thread(() -> { int old = value.get(); // 读取到 100 try { Thread.sleep(100); } catch (InterruptedException ignored) {} boolean ok = value.compareAndSet(old, 101); // 值又是 100,CAS 成功 System.out.println("T1 CAS 结果: " + ok + ", 当前值: " + value.get()); }); // T2:把 100 改成 0,再改回 100 Thread t2 = new Thread(() -> { value.compareAndSet(100, 0); value.compareAndSet(0, 100); }); t1.start(); Thread.sleep(10); // 保证 T1 先读到 100 t2.start(); t1.join(); t2.join(); } } ``` 运行结果的语义是:T1 判断成功,却**无法察觉中间发生过 100→0 的修改**。在"值本身就是唯一语义"时(比如计数器、余额加减)ABA 往往无害;但在依赖**状态变化本身**的场景里就是 Bug,最经典的是用 CAS 实现的无锁栈 / 链表: - 栈顶是节点 A,A 的 next 指向 B; - T1 读到栈顶 A,准备 `CAS(head, A, B)` 把 A 弹出; - 期间 T2 把 A、B 都弹出,又压入了一个新的 A 节点; - T1 的 CAS 成功,但新 head(B)里还留着旧的 next 指针,链表就此错乱。 修复办法是给值配一个**版本号(stamp)**,让"值 + 版本"作为一个整体参与比较,每次修改版本号都递增;这样即使值回到 A,版本也回不去了。 ```java import java.util.concurrent.atomic.AtomicStampedReference; public class AbaFixed { public static void main(String[] args) throws InterruptedException { // 初始值 100,初始版本号 0 AtomicStampedReference<Integer> ref = new AtomicStampedReference<>(100, 0); Thread t1 = new Thread(() -> { int expectedStamp = ref.getStamp(); // 读取当前版本号 Integer old = ref.getReference(); // 读取当前值 try { Thread.sleep(100); } catch (InterruptedException ignored) {} // 值和版本号都要匹配才允许更新;版本号 +1 boolean ok = ref.compareAndSet(old, 101, expectedStamp, expectedStamp + 1); System.out.println("T1 CAS 结果: " + ok + ", 当前值: " + ref.getReference()); }); Thread t2 = new Thread(() -> { int s = ref.getStamp(); ref.compareAndSet(100, 0, s, s + 1); // 值→0,版本 +1 s = ref.getStamp(); ref.compareAndSet(0, 100, s, s + 1); // 值→100,版本 +1 }); t1.start(); Thread.sleep(10); t2.start(); t1.join(); t2.join(); } } ``` 关键点:`compareAndSet` 在这里有 **4 个参数**——期望值、新值、期望版本号、新版本号。因为 T2 已把版本号从 0 改到了 2,T1 拿着旧的版本号 0 去 CAS 会**失败**,从而正确察觉到"中间被改过"。 另一种更轻量的方案是 `AtomicMarkableReference`,它把版本号换成一个**布尔标记**,只关心"有没有被改过"这个二值状态,适合只需标记"已删除 / 已使用"的场景,比如无锁队列里给节点打删除标记。 ### Q:原子类家族有哪些?分别适合什么场景? A:按用途分成五类,记住"改什么就用哪一类": | 类别 | 代表类 | 说明 | | --- | --- | --- | | 基本类型 | `AtomicInteger` / `AtomicLong` / `AtomicBoolean` | 单个基本类型的原子更新 | | 数组 | `AtomicIntegerArray` / `AtomicLongArray` | 数组**每个元素**都能原子更新(不是整个数组) | | 引用 | `AtomicReference` / `AtomicStampedReference` / `AtomicMarkableReference` | 原子更新对象引用,后两个用来解决 ABA | | 字段更新器 | `AtomicIntegerFieldUpdater` / `AtomicReferenceFieldUpdater` | 用反射原子更新**已有类**的某个字段,省去包装对象的内存开销 | | 累加器 | `LongAdder` / `DoubleAdder` / `LongAccumulator` | 高并发计数,内部用分段(Cell)降低热点 | 其中 `AtomicReference` 常用来原子替换"整个引用",比如整体换掉一份配置对象;它保证的是引用替换这一步原子,对象**内部字段**仍要自己保证线程安全,不要误以为包一层就万事大吉。 ### Q:计数器场景下 AtomicLong 与 LongAdder 怎么选? A:核心区别在**热点**。`AtomicLong` 所有线程抢同一个变量,竞争越激烈 CAS 失败越多、自旋越久,吞吐反而下降;`LongAdder` 把计数拆到一个 `base` 加一个 `Cell[]` 数组上,不同线程分散更新不同的 Cell,最后 `sum()` 时再汇总——**用空间换并发**。 ```java import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.LongAdder; public class CounterCompare { private final AtomicLong atomicLong = new AtomicLong(); private final LongAdder longAdder = new LongAdder(); public void incByAtomicLong() { atomicLong.incrementAndGet(); // 所有线程抢同一个变量 } public void incByLongAdder() { longAdder.increment(); // 分散到多个 Cell,热点被打散 } public long atomicSnap() { return atomicLong.get(); // 强一致的瞬时精确值 } public long adderSnap() { return longAdder.sum(); // 并发累加期间可能只是近似值 } } ``` 选型建议: - **只累加、读少、并发高**(如 QPS 统计、监控埋点)→ 用 `LongAdder`,写性能更好; - **需要精确读取、或读写都频繁**(如余额、库存这类要按当前值做判断的)→ 用 `AtomicLong`,因为 `LongAdder.sum()` 在并发累加期间拿到的可能是**近似值**,它不保证强一致的瞬时快照。 一句话:`LongAdder` 适合"**写多读少、只要最终总量**",`AtomicLong` 适合"**要立刻拿到准确值**"。 ### Q:"先判断再更新"的复合操作为什么不能用 AtomicXxx 直接拼? A:因为**每个方法单独原子,不等于两步合起来原子**。看下面这个"取最大值"的错误示范: ```java // 错误示范:check-then-act,两步之间可能被其他线程插入 public void updateMaxWrong(int candidate) { int current = max.get(); if (candidate > current) { max.set(candidate); // 读与写是两次独立操作,中间不是原子的 } } ``` 问题在于:`get()` 和 `set()` 之间存在窗口,多个线程可能同时读到同一个 `current`,各自判断后互相覆盖,最终结果偏小。 正确做法是用 `compareAndSet` 循环把"读—比—写"包成一个自旋重试的原子块: ```java import java.util.concurrent.atomic.AtomicInteger; public class MaxHolder { private final AtomicInteger max = new AtomicInteger(Integer.MIN_VALUE); public void updateMax(int candidate) { int current; do { current = max.get(); // 重新读取当前值 if (candidate <= current) { return; // 没必要更新 } // 只有值还是 current 时才写入 candidate,否则重试 } while (!max.compareAndSet(current, candidate)); } } ``` 关键点:循环条件用 `compareAndSet`,一旦期间被别人改过就失败、回到开头重读,**保证"判断"与"更新"发生在同一个 CAS 上**。该模式可推广到累加、置位、状态机流转等所有复合操作。JDK 8 之后 `Map.compute`、`Map.merge`、`ConcurrentHashMap.compute` 等提供了现成的原子复合方法,能直接用就别自己手写 CAS 循环。 ### Q:CAS 与 synchronized / ReentrantLock 怎么取舍? A:一句话——**竞争低、操作简单用 CAS,竞争高、临界区复杂用锁**。 - **CAS(原子类)**:适合单个变量的简单更新(计数器、状态标记、引用替换),无阻塞、无上下文切换,低竞争下性能极佳。 - **synchronized / ReentrantLock**:适合**多变量要一起保持一致**、或临界区里还有复杂逻辑(IO、方法调用)的场景。CAS 只能保证一个变量原子,硬凑复合操作会让代码又长又易错,此时锁的可读性与正确性更值钱。 还有一个现实约束:CAS 在**高竞争**下自旋失败率高,性能可能被锁反超;这时要么换分段方案(如 `LongAdder`),要么直接用锁,让排队机制替 CPU 省下空转。 ## 四、总结与自测 ### Q:面试里怎么答这道题? A:建议按"定义 → 机制 → 问题 → 选型"四段来答: 1. **定义**:CAS 是"比较并交换",三个操作数 V/A/B,当且仅当内存值等于预期旧值时才更新,整个过程原子;它是无锁乐观并发的基础,用自旋换掉阻塞与上下文切换。 2. **机制**:Java 通过 `Unsafe.compareAndSwapInt` / `VarHandle` 暴露,底层是 CPU 的 `cmpxchg` 指令加 `lock` 前缀(写回主内存 + 让其他核缓存失效);原子类的方法都是"读取—计算—CAS 自旋重试"。 3. **三大问题**:ABA(用 `AtomicStampedReference` 版本号 / `AtomicMarkableReference` 布尔标记解决)、自旋开销(高竞争空转,用 `LongAdder` 分段缓解)、只能保证单变量原子性(复合操作用 `compareAndSet` 循环)。 4. **选型**:单变量简单更新用原子类,多变量或复杂临界区用锁;计数写多读少用 `LongAdder`,要精确读用 `AtomicLong`。 --- ## 自测 1. CAS 的三个操作数 V、A、B 分别是什么?为什么它需要 CPU 的 `lock` 前缀?这个前缀具体做了什么? 2. ABA 问题是什么?在"计数器"和"无锁链表"两种场景里,它的危害有什么不同? 3. `AtomicStampedReference` 与 `AtomicMarkableReference` 解决 ABA 时的区别是什么?各自的 `compareAndSet` 参数有什么变化? 4. 为什么用 `AtomicInteger` 实现"取最大值"必须先 `get` 再 `compareAndSet` 循环,而不能直接 `get` 后 `set`?`LongAdder.sum()` 在并发下为什么可能只是近似值?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入