知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 59 - 并发容器:ConcurrentHashMap 与 CopyOnWriteArrayList > 导读:本文不重复"HashMap 为什么不安全",而是回答更实战的两个问题——**并发容器该怎么选、怎么用对**。我们把 ConcurrentHashMap 的实现演进与常见误用、CopyOnWriteArrayList 的取舍讲透,并给出可直接照搬的正确写法。适合写过并发代码、但不确定"这样用到底对不对"的后端同学。 ## 一、先建立全局认知 ### Q:多线程下用普通集合,到底会出什么问题? A:结论先行——**普通集合(HashMap、ArrayList)没有做任何并发安全设计**,多线程读写会出三类问题。 一是**数据覆盖**:`HashMap.put` 在并发下,两个线程同时落到同一个桶里修改链表,可能后写的把先写的整个顶掉,造成元素丢失。二是**size 不准**:`size` 是"读一个普通变量再加一",自增本身不是原子的,并发累加会丢计数。三是**迭代时抛 `ConcurrentModificationException`(简称 CME,即"并发修改异常")**:集合内部维护一个 `modCount`,迭代过程中只要有别的线程改动结构,`modCount` 和迭代器里的预期值就对不上,立即 fail-fast 抛异常。 这里只需建立"普通集合不能跨线程共享"这一条认知即可,具体为什么覆盖、JDK 8 里 `put` 又是怎么改的,站内《07 - HashMap 的线程安全问题》《ConcurrentHashMap 线程安全实现》已有详述,本文不再展开。 ### Q:并发容器有哪两类解决思路? A:分两大类,理解了它们就掌握了选型的底层依据: - **细粒度加锁 / CAS 路线**:代表是 `ConcurrentHashMap`。它不锁住整个容器,而是尽量把锁散开——早期按段加锁,后来细化到"只锁单个桶"。读操作基本无锁,写操作只锁冲突的那一小块。适合**读写都频繁、数据量大**的场景。 - **写时复制(Copy-On-Write)路线**:代表是 `CopyOnWriteArrayList`。读操作完全不加锁,写操作则复制出一整个新数组、改完再替换引用。适合**读极多、写极少**的场景。 一句话记住选型依据:**看"读多还是写多",而不是看"哪个名字听起来更高级"**。 ## 二、理解核心机制 ### Q:ConcurrentHashMap 在 JDK 7 和 JDK 8 的实现有什么不同? A:核心变化是**锁的粒度从"段"细化到了"桶"**。 JDK 7 用的是**分段锁**:内部是一个 `Segment` 数组,每个 `Segment` 继承 `ReentrantLock`,相当于把整个 Map 切成若干个独立加锁的小 Map。默认 `concurrencyLevel` 是 16,也就是最多 16 个线程真正并行写。定位一个 key 要经过"先算段、再算桶"两段哈希。 JDK 8 直接**取消了 Segment**:底层回到一个 `Node` 数组(和 HashMap 类似,冲突多了会转成红黑树),写入时先用 CAS 尝试把值放进空桶;一旦桶里已有元素,就 `synchronized` **锁住这个桶的头节点**,再操作链表或树。  *图:两种并发容器的思路对比——ConcurrentHashMap 的 CAS + 桶级 synchronized 细粒度加锁,与 CopyOnWriteArrayList 的"写时复制、读不加锁"快照模型。* ### Q:为什么 JDK 8 之后并发度更高?扩容时又是怎么协作的? A:因为**锁的单位从一个"段"(内含多个桶)缩小到一个桶**。JDK 7 里,两个线程就算 key 落在同一段的不同桶,也要争同一把 Segment 锁;JDK 8 里只有真正落到同一个桶头节点才会互斥,冲突概率大幅下降,并发度不再受 `concurrencyLevel` 数量硬性限制。 扩容也做了并发优化。JDK 8 触发扩容后,会用 CAS 修改 `sizeCtl` 标记"正在扩容",然后逐桶搬迁;已经搬空的桶会被放上一个 `ForwardingNode` 占位。**其他线程来写这个桶时,发现是 `ForwardingNode`,就不再傻等,而是调用 `helpTransfer` 一起去搬数据**——把扩容这个重活分摊给多个线程,缩短扩容窗口,这就是"协助扩容"。 ### Q:`size()` 是怎么统计的?为什么说是近似值? A:结论先行——**`ConcurrentHashMap.size()` 返回的是近似值,是弱一致的**。 JDK 8 借鉴了 `LongAdder` 的思路:维护一个基础计数 `baseCount` 和一个 `CounterCell[]` 数组。并发不高时直接 CAS 累加 `baseCount`;一旦 CAS 冲突变多,就把不同线程的增量**分散写到不同的 CounterCell 槽**里,降低热点竞争。`size()` 则把 `baseCount` 和所有 CounterCell 求和得到。 正因为分散写入、又是不加全局锁地累加,**读到的只是某一瞬间的近似总数**,扩容搬迁过程中还会更不准。所以用它做阈值判断或限流是不可靠的(第三节会具体说)。这与站内《04 - 并发计数器》里 LongAdder 的设计是同一套思想:**用空间换竞争**。 ### Q:为什么 ConcurrentHashMap 的迭代器是弱一致的? A:结论先行——**它的迭代器不抛 CME,但也不保证看到最新写入**。 `ConcurrentHashMap` 的迭代器基于数组的某个快照位置往后遍历,遍历过程中允许其他线程继续读写。它不会维护 `modCount` 做 fail-fast 检查,因此**不会抛 `ConcurrentModificationException`**;但如果你在迭代开始后才 `put` 一个落在"已遍历过"位置的元素,这次迭代就看不到它。这种"不保证实时、也不会报错"的特性就叫**弱一致性**。 ### Q:为什么容量必须是 2 的幂? A:为了一句位运算——**`index = (n - 1) & hash`**。 当容量 `n` 是 2 的幂时,`n - 1` 的二进制是一串连续的 1(如 16 → `1111`),此时 `(n-1) & hash` 与 `hash % n` 等价,但**位运算比取模快得多**。`ConcurrentHashMap` 用 `tableSizeFor` 方法把任意传入的初始容量"向上取整"到最近的 2 的幂(例如传 17 会得到 32),就是为了保证这个位运算恒成立。 ### Q:CopyOnWriteArrayList 是怎么做到读不加锁的? A:靠**写时复制(Copy-On-Write)**加一个 `volatile` 数组引用。 内部持有一个 `volatile Object[] array`。所有写操作先加锁,然后**复制出一个新数组、在新数组上完成修改,最后把 `array` 引用整体替换过去**;读操作直接读这个引用指向的数组,完全不加锁、不阻塞。因为 `volatile` 保证引用一旦替换,其他线程立即能看到新数组,读线程永远不会读到"改了一半"的数组。 ```java // 简化的写时复制逻辑,帮助理解机制 public boolean add(E e) { synchronized (lock) { Object[] old = array; // 1. 拿到当前数组 Object[] copy = Arrays.copyOf(old, old.length + 1); // 2. 整体复制 copy[old.length] = e; // 3. 在副本上写入 array = copy; // 4. 原子替换引用(volatile) return true; } } ``` 关键点有三个:**写加锁保证了写与写之间串行**,不会互相覆盖;**复制后再替换**保证了读线程看到的是"完整的旧版或完整的新版";**读不加锁**则是它读性能高的根本原因。 ### Q:写时复制的代价是什么?适用边界在哪? A:代价非常明确,**用写的开销换读的性能**: 1. **每次写都复制整个数组**:数组越大,单次写的内存复制和对象创建越贵。 2. **写操作之间完全串行**:同一把锁,并发写退化成排队。 3. **只保证最终一致性**:写替换引用那一刻之前的读,看到的还是旧数据。 因此它的适用边界很窄:**读极多、写极少,且列表通常不大**——典型是监听器列表、配置快照、白名单这类"启动后基本不变、偶尔整体刷新"的数据。反过来,**频繁写或大列表绝不能用它**,否则每次 `add` 都在复制几千个元素,GC 压力会直接把服务拖垮。 ## 三、放进真实场景 ### Q:ConcurrentHashMap 最容易踩的坑是什么? A:**把多个原子操作拼成一个"看起来原子"的复合操作**。下面这段是经典错误: ```java // ❌ 错误:containsKey 和 put 中间隔着窗口期,两个线程都可能进来 if (!map.containsKey(key)) { map.put(key, load(key)); // 可能被重复执行,甚至被后到的值覆盖 } ``` `containsKey` 和 `put` 各自是线程安全的,但**两行代码合起来不是原子的**——两个线程可能都判断为"不存在",于是都执行了 `load`。正确写法是用容器提供的原子复合方法: ```java // ✅ 错误与正确写法对比 // 原子占位,返回值能告诉你这轮是不是自己抢到的 map.putIfAbsent(key, load(key)); // ✅ 更进一步:computeIfAbsent 只在"key 缺失"时才执行映射函数, // 且整个过程对同一个桶是原子的,天然实现"每键只初始化一次" public class LocalCache { private final ConcurrentHashMap<String, Config> cache = new ConcurrentHashMap<>(); public Config get(String key) { // 只有 key 不存在时才会调用 load 加载;并发下也只加载一次 return cache.computeIfAbsent(key, this::loadFromDb); } } ``` 两个原子方法的分工要记清:**`putIfAbsent` 无论如何都会先把 value 算出来**,只是保证"不覆盖已有值";**`computeIfAbsent` 只在 key 缺失时才执行映射函数**,更适合"加载代价高"的场景。此外还有 `compute`(基于旧值算新值)、`merge`(合并旧值)、`replace`(仅在存在时替换),它们都能把"读-改-写"收敛成一个原子步骤。 ### Q:`computeIfAbsent` 有什么隐藏的坑? A:**映射函数里绝对不要做耗时操作或可能加锁的远程调用**。`computeIfAbsent` 执行映射函数时,是**持有该桶的锁**的——如果函数里去查数据库、调 RPC,这期间其他线程要写同一个桶就会被死死阻塞,一个慢依赖能把整个 Map 的局部写入拖垮。 正确做法是**在锁外先把数据准备好,再用 `putIfAbsent` 放进去**: ```java Config config = loadFromDb(key); // 耗时的加载放在锁外 Config existing = cache.putIfAbsent(key, config); return existing != null ? existing : config; ``` 另外要注意**映射函数里不要再修改这个 Map**,否则可能造成死锁或未定义行为。 ### Q:ConcurrentHashMap 为什么不允许 null 的 key 和 value? A:因为**无法区分"这个 key 不存在"和"这个 key 存在但值是 null"**。 `map.get(key)` 返回 `null` 时,如果是 `HashMap`,你得再 `containsKey` 判断一次;而 `ConcurrentHashMap` 在多线程下这两步之间别的线程可能已经改了状态,判断结果本身就不可信。与其留下这个歧义,它干脆从源头禁止 null——这样"返回 null"就**唯一地表示 key 不存在**,语义干净。 ### Q:`Collections.synchronizedMap` 和 ConcurrentHashMap 怎么选? A:**优先 ConcurrentHashMap,除非你确实需要一个普通的非并发 Map 被包装起来**。 两者的差别在于:`synchronizedMap` 是**单锁**——所有读写争同一把锁,并发度低;而且它只是给每个方法套上 `synchronized`,**复合操作依然不安全**,迭代时还必须手动在 `synchronized(map)` 块里做同步,否则照样抛 CME。`ConcurrentHashMap` 则是桶级锁 + CAS + 无锁读,并发度和易用性都更好。需要并发容器时,直接用 `ConcurrentHashMap`。 ### Q:CopyOnWriteArrayList 怎么用才对?写多时用什么替代? A:先看它的典型正确用法——**注册监听器/刷新配置快照**,同时它天然免疫 CME: ```java public class EventBus { // 读极多(每次事件都要遍历)、写极少(偶尔注册/注销) private final CopyOnWriteArrayList<Listener> listeners = new CopyOnWriteArrayList<>(); public void register(Listener l) { listeners.add(l); } public void fire(Event e) { // 遍历期间即使别的线程 add/remove,也不会抛 ConcurrentModificationException, // 因为遍历的是"写时的快照数组" for (Listener l : listeners) { l.onEvent(e); } } } ``` 关键点:迭代器持有的是**创建迭代器那一刻的数组快照**,所以遍历过程中别处新增的元素本次看不到,删除的元素本次仍会被访问到——这是**最终一致**,不是强一致。业务上如果对"必须看到最新元素"有要求,就不能依赖它。 反过来,**如果写很频繁,就别用它**。替代方案看需求:需要高频并发入队/出队就用 `ConcurrentLinkedQueue`(无锁队列);需要按下标随机访问又写得多,就用普通 `ArrayList` 外加一把 `ReentrantLock` 自己控制临界区。 ## 四、总结与自测 ### Q:面试里怎么答这道题? A:建议按"选型 → 机制 → 误用"三段来答: 1. **先讲选型**:并发容器分两类思路——细粒度加锁/CAS 的 `ConcurrentHashMap`(读写都频繁)与写时复制的 `CopyOnWriteArrayList`(读极多写极少)。选型看读写比例。 2. **再讲机制**:ConcurrentHashMap 从 JDK 7 的 Segment 分段锁演进到 JDK 8 的 CAS + 桶级 `synchronized`,锁粒度更细;扩容支持多线程 `helpTransfer` 协助;`size` 用 `baseCount + CounterCell` 分散热点,是近似值;迭代器弱一致。CopyOnWriteArrayList 写时复制、读不加锁、迭代基于快照。 3. **最后讲误用**:复合操作必须换成 `putIfAbsent` / `computeIfAbsent` / `compute` / `merge`;`computeIfAbsent` 的映射函数里别做耗时调用;别用 `size()` 做限流;ConcurrentHashMap 不允许 null;COW 列表写多时改用 `ConcurrentLinkedQueue` 或加锁的 ArrayList。 一句话收尾:**并发容器的价值不在"线程安全"四个字,而在"把锁的范围缩到最小、把一致性代价控制在可接受范围内"**——理解了这个取舍,选型和用对就都顺了。 --- ## 自测 1. ConcurrentHashMap 的 `size()` 为什么是近似值?如果业务上必须精确统计元素个数,你会怎么做? 2. `map.containsKey(k)` 加 `map.put(k, v)` 为什么不是原子的?请写出至少两种等价的正确写法,并说明 `putIfAbsent` 与 `computeIfAbsent` 的区别。 3. `computeIfAbsent` 的映射函数里为什么不能做耗时的远程调用?在锁外加载再 `putIfAbsent` 的写法规避了什么问题? 4. CopyOnWriteArrayList 的迭代器在遍历时有人 `add`,会发生什么?为什么说它"适用于读多写极少"?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入