跳到主要内容
约 7 分钟2 张卡

Java 原子类

Java 原子类(java.util.concurrent.atomic 包)让一个变量的原子读改写不用加锁也能安全完成。原子读改写是指读取旧值、计算新值、写回这三步作为一个整体生效,中间不会插进别的线程的更新。

原子类解决的是单个变量的正确性,但它不会自动保护「先检查、再修改」这样的多步操作,高竞争下也有性能代价。选择原子类时,除了确认一次方法调用保证了什么,还要考虑竞争集中在一个变量上会怎样,以及 LongAdder 用什么换来了更低的写入竞争。下文以 Java 17 和 21 为准。

1. 面试核心​

先记住这几条,再读正文
  • AtomicLong.incrementAndGet() 原子递增并返回新值,适合进程内发号。
  • 余额检查与扣减必须组成一次条件更新,用 CAS 循环或同一把锁保护;把读取和递减分别换成原子方法,检查之后状态仍可能被改掉。
  • LongAdder 把热点更新分散到 base 和多个 Cell,用更多内存和求和成本换取较低的写入竞争。卡 · 单变量的竞争成本
  • 并发更新期间,LongAdder.sum() 分别读取各个分量,返回值不是同一时刻的原子快照。
  • 并发更新时,sumThenReset() 不会丢计数,但没有统一的窗口分界点;单计数器要精确切分窗口,用 AtomicLong.getAndSet(0)。卡 · 统计窗口与清零

2. 原子类与 CAS 循环​

原子类保证的是单次方法调用的原子性。先看它能解决的问题:多个线程共享一个序列号,每次递增都必须完整生效,否则两个线程可能拿到同一个号。AtomicLong 提供了这样的操作:

private final AtomicLong sequence = new AtomicLong();

long nextId() {
return sequence.incrementAndGet();
}

每次调用都把读取、加一和写回作为一次原子更新,并返回新值,所以不会发出重复的号。这个方案只适合进程内发号,实际使用时还要考虑 long 溢出,以及进程重启后序列从 0 开始。

问题出在把多个原子操作连起来用的时候。下面的库存检查与扣减是两个独立的操作:

if (stock.get() > 0) {
stock.decrementAndGet();
}

库存为 1 时,两个线程可能同时执行 stock.get(),都看到库存大于零。随后两次 decrementAndGet() 各自原子执行,库存变成 -1。每一步都是原子的,但「检查」和「扣减」之间留了一个窗口。

所以检查与扣减要组合成一次条件更新:只有当前值仍然是刚才检查过的那个值时才写入,否则重新读取再试,这就是 CAS 循环;或者用同一把锁把这两步一起包住。CAS 条件更新的写法见 CAS。

3. 单变量的竞争成本​

原子更新解决了正确性,但大量线程同时更新同一个变量时,它们仍然要排队拿写权限,吞吐量会被限制住。

原因在 CPU 缓存。CPU 以缓存行为单位在各核心之间同步数据,缓存行是一块连续的内存,常见大小是 64 字节。一个核心要写某个变量,必须先取得它所在缓存行的独占权限。很多核心轮流写同一个变量时,这个缓存行就在核心之间来回转移,每次转移都要等待。

用 CAS 循环时还有额外开销:CAS 失败的线程要重新读取、重新计算再试。线程虽然没有通过 park 阻塞,CPU 时间却花在了失败重试和缓存同步上。竞争越激烈,失败越多,所以判断成本要同时看更新频率和竞争强度。

另外,AtomicLong 的 API 只保证原子读改写的语义,一次方法调用不一定对应一次 CAS 指令。原子加法具体用什么底层指令,由 JVM 和处理器决定。

4. LongAdder 的分段累加​

LongAdder 适合写多读少的统计场景,它把竞争中的更新分散到多个位置,让线程不必都挤在一个变量上。请求量统计就是这样的场景:每个请求都要累加一次,读取只用于监控。

private final LongAdder requests = new LongAdder();

void recordRequest() {
requests.increment();
}

long observedRequests() {
return requests.sum();
}

OpenJDK 21 的实现由一个基础值 base 和一个 Cell 数组组成,每个 Cell 保存一部分累加值。竞争低时,更新直接落到 base 上,和 AtomicLong 差不多。一旦更新 base 发生竞争,才创建或扩展 Cell 数组,让不同线程更新不同的 Cell,彼此不再争同一个位置。

读取时,sum() 把 base 和所有 Cell 的值加起来。这就是它的代价:多个 Cell 要占更多内存,读取一次要遍历所有分量。示例里的 observedRequests() 读取频率低、只用于监控,正好能接受这种代价。

5. sum() 的读取语义​

sum() 逐个读取分量时,其他线程还在更新,各个分量是在不同时刻读到的,所以求和结果不是同一时刻的整体原子快照。比如读完 base 之后,另一个线程往已经读过的 Cell 里加了 1,这次增量就不在结果里;而它加在还没读到的 Cell 里时,又会被算进去。

所有更新停止,并且对读取线程可见以后,sum() 的结果是精确的。并发写入期间,它适合指标、频次这类统计,但下面这些需要一致性的场景要用别的方案:

  • 生成唯一序列号,需要一次原子递增并返回新值。
  • 计数到某个精确值时触发一次状态转换,需要把判断和更新合成一步。
  • 让计数和另一个字段组成一致的快照,需要把这些字段一起读取或一起替换。
  • 精确切分结算周期,需要给计数和清零一个共同的分界点。

对应的做法是:单变量的读改写用 AtomicLong,多字段状态用锁,或者用不可变对象加原子引用;也可以把事件交给一个线程统一处理,由它独占状态。

6. AtomicReference 与不可变状态​

几个字段需要一起变化时,可以把它们放进一个不可变对象,再用 AtomicReference 原子地替换整个引用。比如库存数量和版本号要一起更新,可以用 record 定义状态:

record State(int available, long version) {}

AtomicReference<State> state =
new AtomicReference<>(new State(10, 0));

初始状态是可用数量 10、版本 0。更新时不修改旧对象,而是构造一个新的 State,再用 CAS 把引用从旧对象换成新对象。CAS 成功,两个字段就作为一组同时生效;失败说明有人先改了,重新读取再试。

读取方要先保存一次 get() 的结果,再从这个对象上读各个字段,这样读到的一定是同一个版本。如果每读一个字段都重新调用一次 get(),两次调用之间有人更新了状态,就会读到旧的 available 和新的 version。

这个方案的代价是每次更新都分配新对象,竞争高时还会反复重试,也要考虑 ABA 问题。状态转换比较复杂时,用锁覆盖多步操作更容易检查正确性。更新函数在重试时要注意的约束见 CAS。

7. 统计窗口与清零​

按时间段统计时,「读出旧窗口的计数」和「开始新窗口」之间需要一个清楚的分界点,LongAdder 给不了这个分界点。reset() 要求在没有并发更新时调用;sumThenReset() 也是逐个读取并清零各个分量,整个操作没有统一的原子时刻。写线程和清零交错时,同一时刻发生的几次递增,有的落在已经清零的 Cell 上、算进新窗口,有的落在还没处理的 Cell 上、算进旧窗口,窗口的边界就说不清了。

两个方法的差别在于会不会丢计数。OpenJDK 21 的 sumThenReset() 对每个分量用原子交换取出旧值并写入 0,并发递增要么算进这次返回值,要么留给下一个窗口,不会丢失。reset() 则直接把分量写成 0,刚加上去、还没被读走的增量会被抹掉。在 Temurin 21 上用 8 个线程持续递增、同时反复调用 sum() 再 reset(),统计到的总数明显少于实际递增次数;换成 sumThenReset(),总数和递增次数一致。

单个计数器需要原子切换窗口时,用 AtomicLong.getAndSet(0)。它在一次原子操作里返回旧值并写入零,每次并发递增要么在交换之前、算进旧窗口,要么在交换之后、算进新窗口。多个计数器要组成同一时刻的快照时,仍然需要统一加锁,或者交给同一个更新线程协调。

8. 常见问题​

8.1 LongAdder 一定比 AtomicLong 快吗?​

不一定。LongAdder 的优势出现在高竞争、累加远多于读取的负载上。竞争低时,两者性能差异可以很小,而 AtomicLong 占用空间更少、读取也更便宜。要下结论,应在目标硬件上按真实线程数和读写比例做 JMH 基准,再结合运行时的性能采样判断。

8.2 用了原子类,整段逻辑就线程安全了吗?​

9. 面试题卡片​

先想答案,再翻面先在心里答一遍,再点开卡片对照参考回答。卡片之间可以左右切换,看完会回到这里。
逐张翻看 2 张 →
未标记的卡读完后明天进入复习;已标记的按状态安排

10. 参考资料​

来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明