知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 04 - 高并发计数器 > 导读:本文用一问一答的方式,把"高并发计数器"这道题从 synchronized、AtomicLong、LongAdder 讲到自定义分段锁,讲清 CAS 的适用边界、ABA 问题,以及 AtomicLong 与 LongAdder 该怎么选。适合准备 Java 并发面试、或在统计类场景里纠结"用哪个计数器"的开发者阅读。 ## 一、先建立全局认知 ### Q:"实现一个高并发下的线程安全计数器"考察点是什么? A:结论先行——这道题的关键词是"**高并发**",所以考察重点不是"能不能线程安全",而是"**线程安全的同时性能好不好**": 1. **是否知道多种实现及其性能梯度**:`synchronized` → `AtomicLong` → `LongAdder`,从重到轻。 2. **是否理解无锁(lock-free)原理**:CAS 是什么、怎么自旋、为什么会失败。 3. **是否有取舍意识**:能不能说清 `LongAdder` 快在哪、代价是什么(读取不精确),以及什么场景该退回 `AtomicLong`。 答题时按"从简到优"的顺序铺开,最后落在"写多读少用 LongAdder、要精确实时值用 AtomicLong"这条结论上,就是一个完整的回答。 ### Q:为什么"计数"这件事在高并发下会变成一道难题? A:因为计数本质上是一个**共享可变状态**上的"读—改—写"操作。`count++` 看似一行代码,实际包含"读取 → 加一 → 写回"三步,不是原子操作。 在单线程下没问题,但在高并发下有两种典型解法: - **加锁**:让同一时刻只有一个线程能执行递增,保证正确性,但线程被串行化,竞争越激烈、性能越差。 - **无锁(CAS 自旋)**:不加锁,用 CPU 提供的原子指令"比较并交换",失败就重试。 而高并发场景的难点在于:无论加锁还是 CAS,只要**所有线程都争抢同一个变量**,这个变量就会成为热点,成为性能瓶颈。这三种方案的本质,就是"如何把竞争分散开"的层层递进。 ## 二、理解核心机制 ### Q:方案一:用 synchronized 怎么写?为什么性能最差? A:最直观的写法是把读和写都加上 `synchronized`: ```java public class SyncCounter { private long count = 0; public synchronized void increment() { count++; } public synchronized long get() { return count; } } // 问题:所有线程串行执行,高并发下锁竞争严重 ``` 它一定正确——`synchronized`(Java 内置的互斥锁,即监视器锁)保证同一时刻只有一个线程能进入方法体。但代价也很明显: - **所有线程串行执行**:并发度直接退化到 1,线程越多、排队越久。 - **加锁解锁本身有开销**:涉及用户态/内核态切换和上下文切换,热点方法上这笔开销被放大。 所以它只适合并发很低,或逻辑复杂、必须整体互斥的场景,在高并发计数上是最差的一档。 ### Q:方案二:AtomicLong 怎么实现无锁计数?CAS 原理是什么? A:`AtomicLong` 用一个 `volatile` 值 + CAS 循环替代锁: ```java import java.util.concurrent.atomic.AtomicLong; public class AtomicCounter { private final AtomicLong count = new AtomicLong(0); public void increment() { count.incrementAndGet(); // CAS 操作,无锁 } public long get() { return count.get(); } } ``` CAS 是它无锁的根基: ``` CAS(Compare And Swap):比较并交换 incrementAndGet() 的底层逻辑: do { long current = count.get(); // 读取当前值 long next = current + 1; // 计算新值 } while (!count.compareAndSet(current, next)); // 如果当前值还是 current,就更新为 next,否则重试 ``` ``` CAS 是 CPU 级别的原子指令(LOCK CMPXCHG),不需要加锁 ``` 它的思路是"乐观并发":**先假设没人跟我抢**,读到旧值 `current`、算出新值 `next`,提交时用 `compareAndSet` 检查"当前值是否仍是 `current`"——是则更新成功,否则说明被别人改过,重新读取再来一轮。 相比 `synchronized`,它的优势是**避免了线程阻塞和上下文切换**,线程始终在用户态自旋。代价是:并发越高、失败重试越多,自旋会空耗 CPU;而且它依旧让所有线程争抢同一个变量,热点问题没有根本解决。 ### Q:CAS 有什么缺陷?"ABA 问题"是怎么回事? A:经典缺陷之一就是 ABA: ``` 线程 1 读到 count = 0 线程 2 将 count 改为 1,再改回 0 线程 1 CAS 成功(值还是 0),但中间发生了变化 对于计数器,ABA 问题不影响正确性(只关心最终值) 对于需要感知中间状态的场景(如链表节点),用 AtomicStampedReference 加版本号 ``` 要理解它,关键是分清两种场景: - **只关心最终值**(如计数):中间"变过又变回来"无所谓,ABA 不影响正确性,这也是 `AtomicLong` 在计数场景可用的原因。 - **关心中间状态**(如无锁链表的节点是否被替换过):值虽然相同,但对象可能已经不是原来那个,此时需要用 `AtomicStampedReference`(带版本戳的引用)给引用附加一个版本号,比较时同时比较"引用 + 版本"。 除了 ABA,CAS 还有两个常见局限:**只能保证单个变量的原子性**(多变量要另想办法),以及**高竞争下自旋开销大**——后者正是下一节 `LongAdder` 要解决的问题。 ### Q:方案三:LongAdder 为什么比 AtomicLong 快? A:因为它把"一个热点变量"拆成了"多个分散的计数单元",概念上就是分段累加: ```java import java.util.concurrent.atomic.LongAdder; public class LongAdderCounter { private final LongAdder count = new LongAdder(); public void increment() { count.increment(); } public long get() { return count.sum(); } } ``` 其内部机制与代价如下: ![LongAdder 分段累加:base + Cell[]](/images/sc-p776-7.svg) *图:LongAdder 分段累加:base + Cell[]* ``` AtomicLong 的问题: 高并发时,多个线程同时 CAS 同一个变量 大量 CAS 失败,线程自旋重试,CPU 浪费严重 LongAdder 的解决方案:分段累加 维护一个 base 值 + 一个 Cell[] 数组 低竞争时:直接 CAS 更新 base 高竞争时:每个线程更新自己对应的 Cell(减少竞争) 读取时:sum = base + Σ Cell[i] ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ │ base │ + │Cell 0│ + │Cell 1│ + │Cell 2│ = 总计数 └──────┘ └──────┘ └──────┘ └──────┘ 线程 A 更新 Cell 0,线程 B 更新 Cell 1,互不干扰 代价: 读取时需要汇总所有 Cell,不是实时精确值 适合写多读少的场景(如统计 QPS、PV) ``` 翻译成取舍语言: - **为什么快**:`AtomicLong` 让 N 个线程抢一个变量,`LongAdder` 让它们分散到 N 个 `Cell` 上各自成交,把"热点"摊平了。竞争越激烈,收益越明显。 - **代价是什么**:`sum()` 需要遍历汇总所有 `Cell`,**不是实时精确值**——在并发写入的同时调用 `sum()`,可能读到"中间态"。因此它适合**写多读少**的场景(埋点计数、QPS/PV 统计),不适合需要精确快照的场景。  [编辑 Excalidraw 源图](/images/java-interview-copy/concurrent/04-concurrent-counter-concurrent-counter-long-adder-diagram.excalidraw) ### Q:方案四:能不能自己手写一个分段锁版本,来理解 LongAdder 的思路? A:可以,思路是"按线程分散到不同的锁和计数槽",这正是 `LongAdder` 的简化思想: ```java public class SegmentedCounter { private final int segments; private final long[] counts; private final Object[] locks; public SegmentedCounter(int segments) { this.segments = segments; this.counts = new long[segments]; this.locks = new Object[segments]; for (int i = 0; i < segments; i++) { locks[i] = new Object(); } } public void increment() { // 根据线程 ID 选择分段,减少竞争 int segment = (int) (Thread.currentThread().getId() % segments); synchronized (locks[segment]) { counts[segment]++; } } public long get() { long total = 0; for (long count : counts) { total += count; } return total; } } // 这就是 LongAdder 的简化版思路 ``` 它和 `LongAdder` 的核心思想一致,但有几个需要注意的差异: - **分散维度不同**:这里按"线程 ID % 分段数"固定映射,一个线程永远落在同一个槽位上;`LongAdder` 用 `Cell` 数组 + 探测(probe)机制动态选择槽位,抗冲突能力更强。 - **`get()` 依然要汇总**:和 `LongAdder.sum()` 一样,读取不是单个原子变量的快照,并发下同样不保证精确。 - **它演示的是思路,不是替代品**:生产代码里应该直接用 `LongAdder`,自己写反而更容易在分段哈希、扩容等细节上出错。 ### Q:四种方案的性能差距有多大? A:原文给出了一个参考对比(具体数字与机器、JDK 版本、压测方式强相关,仅用于说明量级差异,实际请以自己环境的基准测试为准): ``` 并发线程数:100,每线程操作:100万次 synchronized: ~8000ms(锁竞争严重) AtomicLong: ~3000ms(CAS 自旋) LongAdder: ~800ms(分段,几乎无竞争) 结论: 低并发(< 10 线程):AtomicLong 足够 高并发(> 10 线程):LongAdder 性能更好 需要精确实时值:AtomicLong(LongAdder.sum() 不是实时精确的) ``` 这张表的意义不在于记住具体毫秒数,而在于记住**性能梯度的方向**:加锁 < CAS < 分段累加,原因是竞争被逐级"摊薄"。同样地,"< 10 线程"这类阈值也只是经验参考,需要结合版本和实际压测确认。 ## 三、放进真实场景 ### Q:AtomicLong 和 LongAdder 到底怎么选? A:判断依据是"**读写比例**"和"**是否要精确实时值**": - **低并发,或需要精确实时值**:用 `AtomicLong`。它的 `get()` 返回的是某个精确时刻的值,语义清晰。 - **高并发、写多读少**:用 `LongAdder`。典型场景是统计 QPS、PV、接口调用次数这类"只累加、偶尔读一下"的指标。 补充一句:如果读也很频繁,还可以考虑"写用 `LongAdder`、读时先 `sum()` 再缓存"的思路,但这属于优化手段,不在本题范围内。 ### Q:这道题的答案在生产环境要注意什么? A:几个容易被忽略的工程要点: - **计数器无法持久化**:`AtomicLong`/`LongAdder` 都是进程内内存值,重启即清零。需要持久化就要落库或写时序数据库。 - **多节点不共享**:内存计数器只在单个 JVM 内有效,集群下要么做汇总,要么直接用 Redis 的 `INCR` 之类的分布式计数方案。 - **`sum()` 的不精确是有意设计**:不要把 `LongAdder` 用在对账、扣减这类要求强一致的场景,否则会引入难以排查的业务问题。 - **`volatile` 与 `long`**:方案的 `SyncCounter` 中 `count` 被 `synchronized` 保护,读写都在同一把锁内,所以不需要额外的 `volatile`;若去掉锁,则要考虑可见性问题。 ### Q:如果面试官追问"为什么 CAS 是无锁的,它比加锁快在哪"? A:因为加锁在竞争激烈时会让线程**阻塞并进入内核态等待**,涉及挂起/唤醒和上下文切换,代价高;CAS 则是**用户态的原子指令 + 自旋重试**,线程从不阻塞,省掉了切换开销。但"无锁"不等于"无开销"——它用"失败重试消耗 CPU"换来了"不阻塞",所以在竞争极激烈时反而可能因为大量自旋而变慢,这正是 `LongAdder` 分段进一步优化的动机。 ## 四、总结与自测 ### Q:面试里怎么答这道题? A:按"从简到优 + 给出选型结论"来答: 1. **给梯度**:`synchronized`(互斥锁,串行、最慢)→ `AtomicLong`(CAS 无锁,但仍有热点)→ `LongAdder`(分段累加,把热点摊开,高并发最快)。 2. **讲原理**:`AtomicLong` 靠 CAS 自旋实现原子递增;`LongAdder` 维护 `base + Cell[]`,高竞争时各线程更新各自的 `Cell`,读取时用 `sum()` 汇总。 3. **点代价**:`LongAdder.get()`(即 `sum()`)在并发写入时不是实时精确值,只适合写多读少;需要精确实时值就用 `AtomicLong`。 4. **提边界**:CAS 有 ABA 问题(计数场景无影响,需感知中间状态时用 `AtomicStampedReference`),且只保证单变量原子性。 ### Q:一句话总结这道题的核心结论是什么? A:**计数器的本质是把"竞争"从线程身上挪走**——加锁靠串行化保证正确性(代价大),CAS 靠自旋避免阻塞(仍有热点),`LongAdder` 靠分段把热点摊平(读不精确)。选择哪个,取决于并发量、读写比例和对精确性的要求。 --- ## 自测 1. 为什么 `LongAdder` 在高并发下比 `AtomicLong` 快?它在 `increment()` 和 `sum()` 上分别付了什么代价? 2. CAS 的 ABA 问题在计数场景为什么可以忽略?在什么场景必须用 `AtomicStampedReference` 解决? 3. 如果需要"精确的实时计数"且并发不高,你会选 `synchronized`、`AtomicLong` 还是 `LongAdder`?为什么?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入