mobile wallpaper 1mobile wallpaper 2mobile wallpaper 3mobile wallpaper 4
2350 words
6 minutes
Java CAS 专题:从 AtomicInteger 到乐观并发
2025-04-02
2026-09-28

AtomicInteger.incrementAndGet() 可以让多个线程安全地递增同一个计数器。它与普通 count++ 的区别是什么?如果把数字换成库存,是否就能直接用来防超卖?

CAS 是一种原子地“比较并更新”的操作。理解它,关键在于看清三个边界:比较的是哪个状态,失败以后重新做什么,以及整个业务流程是否都在这一次原子更新之内。

本文以 Java 21 为基准,从一次 CAS 开始,逐步展开重试、不可变快照、ABA 和 LongAdder。完整的本地实验见文末。

1. 一次 CAS 只做一次条件更新#

以 AtomicInteger 为例:

AtomicInteger stock = new AtomicInteger(10);
boolean first = stock.compareAndSet(10, 9); // true
boolean second = stock.compareAndSet(10, 8); // false
int current = stock.get(); // 9

可以把 compareAndSet(expected, next) 理解为:

如果当前值等于 expected:
原子地改成 next,返回 true
否则:
不修改,返回 false

“原子地”意味着比较与更新是一个不可被其他线程拆开的操作。它不同于以下代码:

// 错误示意:检查与写入之间允许其他线程修改 stock
if (stock.get() == 10) {
stock.set(9);
}

一次 compareAndSet 失败后不会自动帮你刷新预期值,也不会自动再试。是否重试、根据什么新状态重算,都需要调用方决定。AtomicInteger API

2. 重试为什么必须重新读取和计算#

设两个线程都读到库存为 10:

顺序发生的事情
1A 计算要把 10 改成 9
2B 也计算要把 10 改成 9
3A 的 CAS 成功,库存变成 9
4B 的 CAS 失败,旧前提已经失效
5B 重新读到 9,再尝试改成 8

失败后继续反复提交“10 改成 9”,没有意义。正确的重试应重新读取当前状态,并重新检查业务条件。

下面是单 JVM 内的库存扣减片段:

boolean reserve(AtomicInteger stock, int quantity) {
if (quantity <= 0) {
throw new IllegalArgumentException("quantity must be positive");
}
for (;;) {
int before = stock.get();
if (before < quantity) {
return false;
}
int after = before - quantity;
if (stock.compareAndSet(before, after)) {
return true;
}
}
}

前提是库存初始非负,所有写入者都遵守同样的约束。判断余额与条件更新共同构成扣减操作;不能先 decrementAndGet() 再看是否小于 0,否则负库存已经被公开,补回也引入了额外交错。

这个循环适合说明 CAS 重试模型。持续竞争时,某个线程可能反复失败,因此它不保证每个调用都在固定步数内结束。在线服务还需考虑截止时间、竞争退避或改用更合适的同步方案。

incrementAndGet() 等原子方法已经封装了所需行为,日常计数直接使用即可。不要把用于解释的 Java 循环当成所有 JDK、所有硬件上的实际实现;底层可能采用不同的原子指令。

3. CAS 保护一个位置,也可以提交一份完整快照#

库存经常不只一个字段,还需要同时维护:

available + sold = initialStock

分别使用两个 AtomicInteger,不能让“扣 available”和“加 sold”变成一个整体;读者可能在两次更新之间观察到不一致。

一种选择是给这两个字段加同一把锁。另一种选择是把相关状态装进不可变对象,用 AtomicReference 一次替换整份快照。

实验工程中的实现如下:

public record State(int available, int sold) {}
private final AtomicReference<State> state;
public boolean reserve(int quantity) {
if (quantity <= 0) {
throw new IllegalArgumentException("quantity must be positive");
}
for (;;) {
State before = state.get();
if (before.available() < quantity) {
return false;
}
State after = new State(
before.available() - quantity,
before.sold() + quantity);
if (state.compareAndSet(before, after)) {
return true;
}
}
}

构造时把 state 初始化为 new State(initialStock, 0),并校验库存非负。每次失败重试会生成基于新快照的候选值;成功时,两个字段作为同一份快照发布。

读取时也应只获取一次快照:

State snapshot = state.get();
int total = snapshot.available() + snapshot.sold();

如果两次调用 state.get() 分别读取两个字段,仍可能混合两个版本。

这里的 record 只有整数,所以快照不可变。换成包含 List 的 record 时,record 本身不会让列表内容自动不可变。快照内容若被原地修改,就破坏了这个设计的前提。

4. AtomicReference 比较的是引用身份#

数值相等与引用相同不是一件事:

String original = new String("ready");
String sameText = new String("ready");
AtomicReference<String> ref = new AtomicReference<>(original);
System.out.println(original.equals(sameText)); // true
System.out.println(ref.compareAndSet(sameText, "done")); // false
System.out.println(ref.compareAndSet(original, "done")); // true

AtomicReference.compareAndSet 使用引用身份比较,不调用业务对象的 equals()。前面的库存实现必须保留 get() 取得的 before 引用,再用它作为 CAS 的预期对象。AtomicReference API

因此,不能重新构造一个字段相同的 State,期待它能代表当前持有的那份快照。

5. 重试函数里为什么不能发消息#

updateAndGet 能让一些更新更简洁:

AtomicInteger version = new AtomicInteger();
int next = version.updateAndGet(value -> value + 1);

但更新函数可能因为竞争被多次求值。把副作用放进去,会导致“原子值只成功改了一次,外部动作却执行了多次”:

// 错误示例:函数可能被重复执行
version.updateAndGet(value -> {
sendNotification();
return value + 1;
});

更新函数应只计算候选值,不发送消息、不写数据库、不扣外部账户,也不要修改传入的旧快照。

把通知移到 CAS 成功以后,可以避免重试函数本身重复发送,但仍不能保证通知可靠送达:内存更新后进程可能崩溃,通知尚未发出。涉及持久化业务效果,应使用数据库事务与事件记录等机制,见业务并发实战。

6. ABA:值相同,不等于没有发生变化#

普通 CAS 只比较当前值。考虑以下历史:

T1 读取到 A,暂停
T2 将 A 改为 B
T2 又将 B 改回 A
T1 用“预期值 A”执行 CAS,成功

T1 看不出中间发生过两次修改。这是否构成问题,取决于业务是否关心这段历史。只关心当前数值的操作未必需要处理 ABA;基于旧结构关系计算后续修改的算法,可能因此使用已经失效的前提。

需要识别历史变化时,可以把版本号与引用一起比较:

Object a = new Object();
Object b = new Object();
Object c = new Object();
AtomicStampedReference<Object> ref =
new AtomicStampedReference<>(a, 0);
int[] stamp = new int[1];
Object observed = ref.get(stamp);
// 用顺序代码明确模拟另一个写入者的两次修改
ref.compareAndSet(a, b, 0, 1);
ref.compareAndSet(b, a, 1, 2);
boolean accepted = ref.compareAndSet(
observed, c, stamp[0], stamp[0] + 1);
System.out.println(accepted); // false

get(stamp) 一次取得匹配的引用和版本。分别调用 getReference()、getStamp() 时,两次调用之间可能发生更新,得到不属于同一时刻的一对值。

所有写入者都必须正确推进版本;stamp 是有限范围的整数,不能在无限历史下忽略重复或回绕。这个工具检测的是“引用与版本都未变”的前提,不是自动实现完整事务。AtomicStampedReference API

7. LongAdder 为什么适合统计,不适合抢名额#

高竞争下,所有线程更新同一个原子计数位置,会争用同一份状态。LongAdder 通过分散更新、读取时汇总的方式改善这类统计负载,但也改变了读取语义。

LongAdder requests = new LongAdder();
requests.increment();
long observed = requests.sum();

有线程持续写入时,sum() 不是一个对所有分量的原子快照;所有写入停止并建立好完成同步后,再读取总和,则可以得到准确结果。不能把它简化成“LongAdder 永远不准”。LongAdder API

对于请求次数、流量指标,这种权衡通常可以接受。对于“最多放行 100 人”,以下方式没有把判断与增加合成一个原子动作:

// 错误示例:多个线程可能同时看到还有名额
if (requests.sum() < 100) {
requests.increment();
allow();
}

名额分配应使用带条件的 CAS、信号量,或由数据库承担的业务约束,具体取决于名额的范围和持久化要求。

8. CAS、锁和数据库怎么选#

需求优先考虑
单个计数增减AtomicInteger / AtomicLong
并发统计指标LongAdder
小型不可变状态转换AtomicReference
多步内存逻辑同一把锁保护临界区
多实例业务修改数据库约束与事务

CAS 避免了以互斥锁方式排队进入临界区,但失败重试也会消耗 CPU。在高竞争下,不断生成候选对象还会增加分配与回收开销,所以“无锁一定更快”没有普遍成立的依据。

无锁进展保证关注系统整体能否继续推进,不表示每个线程都能及时成功;也不能只要代码中出现一次 CAS,就把整段包含 I/O 的算法称为无锁算法。

Java 原子变量只协调共享同一个内存对象的线程。两台服务器各自维护一个 AtomicInteger(100),合起来不是一份全局库存。数据库的带版本条件更新在思路上类似比较后提交,但执行机制、故障和事务范围都不同。

9. 对照实验,观察保证的范围#

下载 Java 并发实验工程,在 JDK 21、Maven 3.9 环境执行:

mvn test

工程的 12 项测试中,有几项直接对应本文:

  • 8 个工作线程竞争 100 份库存,共尝试 400 次;验证成功 100 次、余额为 0,且每份读取到的快照都保持总数为 100。
  • 非法数量和超额请求被拒绝,不改变库存。
  • 两个内容相等但不同身份的引用,不能通过引用 CAS。
  • 固定安排 A → B → A,比较普通引用和带版本引用的结果。
  • 所有计数任务结束后,再读取 LongAdder,验证最终总和。

ABA 测试刻意用顺序代码表达确定的交错历史;它不是一次性能压测。库存测试验证的是这个内存对象的约束,也不包含下单事务、数据库恢复或跨实例一致性。

Share

If this article helped you, please share it with others!

Java CAS 专题:从 AtomicInteger 到乐观并发
https://mizuki.mysqil.com/posts/java-cas/
Author
梦幻晨风
Published at
2025-04-02
License
CC BY-NC-SA 4.0

Some information may be outdated

Table of Contents