CopyOnWrite 容器
CopyOnWrite 容器(CopyOnWriteArrayList 和 CopyOnWriteArraySet)的做法是写时复制:每次修改列表结构,都先复制一份新数组,在新数组上改完,再把引用换过去。读者和迭代器手里拿的始终是某个完整的旧数组,所以读取不用加锁,遍历也不会抛并发修改异常。代价全部落在写入上:每写一次复制 n 个引用,旧数组还可能被迭代器拖着不能回收。所以它只适合小规模、读远多于写的列表,比如监听器列表。判断能不能用它,就看读写比例、列表大小和能否接受旧快照。下文以 OpenJDK 21 为准。
1. 面试核心
先记住这几条,再读正文- CopyOnWriteArrayList 在写锁内复制元素引用、完成结构更新,再发布新数组。卡 · 读操作
- 迭代器遍历的是创建时的数组快照,之后的增删和替换都不会影响这次遍历。卡 · 读操作
- 长时间持有的迭代器会延长旧数组及其元素的存活时间。
- 写时复制只复制元素引用,元素字段的并发读写仍要由元素自己保证线程安全。卡 · 不适合的场景
addIfAbsent把检查和插入作为一个原子操作完成;分开调用contains和add会有重复插入的竞态。卡 · 原子去重插入
2. 读操作
读操作要拿到的,是一个已经构造完成的数组版本。容器用一个 volatile 字段保存当前数组的引用,get 先读这个引用,再按索引取元素。遍历同样基于这个数组,比如下面的监听器广播:
CopyOnWriteArrayList<Listener> listeners = new CopyOnWriteArrayList<>();
for (Listener listener : listeners) {
listener.onEvent(event);
}
volatile 保证新数组的引用发布之后,读到这个引用的线程也能看到数组里已经写好的内容。写者总是先构造好完整的新数组,最后才替换引用,所以读者不需要获取写锁,也不可能看到复制到一半的数组。
3. 写入与数组复制
写操作必须防止多个线程同时基于同一个旧数组修改,否则后发布的新数组会覆盖前一次的修改。所以加入元素时,要在写锁的保护下依次完成:
- 获取写锁。
- 读取当前数组。
- 分配一个长度加一的新数组。
- 复制旧数组的引用,再写入新元素。
- 发布新数组的引用。
删除成功,或者把某个位置替换成不同的引用时,同样要复制数组:
listeners.add(listener);
listeners.remove(listener);
新增一个元素要复制已有的 n 个引用,成本是 O(n),还要分配一个新数组。写入集中时,多个写者要排队等同一把锁,大量复制也会占用内存带宽。新旧数组同时存活,会抬高内存峰值,也增加垃圾回收(GC)的压力。
是否真的复制,取决于操作结果。OpenJDK 21 中,set 写入的是同一个引用时不会复制数组,删除一个不存在的元素也会直接返回。
4. 快照迭代器
迭代器在创建时保存当时的数组引用,这个数组就是这次遍历的快照。之后的修改都发生在新数组上,快照不会变:
Iterator<Listener> iterator = listeners.iterator();
listeners.add(newListener);
while (iterator.hasNext()) {
iterator.next(); // 不会看到 newListener
}
iterator 一直读的是旧数组,所以看不到后加入的 newListener。也正因为如此,并发增删或替换元素都不会让它抛出 ConcurrentModificationException(并发修改异常)。
快照迭代器只能读。Iterator.remove 会抛出 UnsupportedOperationException,ListIterator 的 set 和 add 也一样。
放到广播场景里看:一次广播只会通知迭代器创建时已有的监听器,新注册的要等下一次广播;广播过程中注销的监听器还在旧数组里,轮到它时照样会收到回调。如果业务要求注销后立即停止接收,监听器自己要检查是否仍然有效。
5. 适合的场景
用不用 CopyOnWrite,要同时看列表规模、读写比例和快照要求:
- 列表比较小。
- 读和遍历的频率远高于写。
- 遍历比较耗时,不希望一直占着锁。
- 读者能接受短时间内看到旧版本。
- 写入只由少量的管理操作触发。
满足这些条件的,通常是这类小型列表:
- 事件监听器列表。
- 运行期间很少变化的规则或处理器清单。
- 小规模的路由快照。
- 偶尔才更新的白名单。
列表大小要单独考虑。一个有百万元素的列表,哪怕每天只更新几次,每次也要完整复制整个数组。所以评估时还要看单次复制的延迟和内存峰值,不能只看写入次数。
6. 不适合的场景
复制数组和读旧快照都有代价,下面这些更新与一致性要求会让 CopyOnWrite 不再合适:
- 写入频繁,或者把一批数据拆成很多次单条写入。
- 列表很大,复制会造成明显的内存峰值。
- 要求写入之后,所有正在进行的遍历立刻看到新内容。
- 业务需要通过迭代器修改列表。
- 多个线程会修改元素的字段,并且指望容器来保护这些字段。
最后一条要分清数组和元素对象。CopyOnWrite 复制的只是引用数组,新旧数组指向的还是同一批元素对象:
listeners.get(0).changeState();
这次调用改的是 Listener 对象自己的状态。其他快照里引用的也是这个对象,所以它的字段读写要由 Listener 自己同步,容器管不到。
7. 原子去重插入
「不存在才插入」需要把检查和插入合成一个原子操作。分开调用 contains 和 add 时,两个写者可能同时发现元素不存在,然后各插入一次,列表里就有了两份。addIfAbsent 会在写锁内确认元素仍然不存在,再发布新数组:
boolean added = listeners.addIfAbsent(listener);
返回 true 表示这次插入成功,false 表示已经有相等的元素。相等用 equals 判断,所以参与比较的字段要保持稳定。要批量去重插入,可以用 addAllAbsent,减少数组发布的次数。
8. 批量更新
既然每次写入都要复制整个数组,一批元素就应该一次性加入。下面是单条追加与批量追加两种写法(二选一):
// 逐个追加
for (Listener listener : incoming) {
listeners.add(listener);
}
// 批量追加
listeners.addAll(incoming);
- 逐个
add时,每次都要复制一遍已有数组,而且越往后加,要复制的引用越多。 addAll只构造一次新版本,复制和发布都只做一次。
addIfAbsent 和 addAllAbsent 需要逐个扫描比较元素。去重很频繁时,基于哈希的 Set 更合适,再按线程共享方式加上同步。配置是按批次整体变化的话,也可以干脆整体替换一个不可变快照。
整体替换的做法是:先构造一个不可变 List,再通过 volatile 字段或 AtomicReference(原子读取和更新对象引用的类)一次性替换引用。这样写入成本集中在构造快照的那一刻,读者只要取一次引用,就固定了这次读取看到的列表版本。
9. CopyOnWriteArraySet
需要去重、又想要快照遍历时,可以用 CopyOnWriteArraySet。它内部就是一个 CopyOnWriteArrayList,靠逐个比较元素判断是否重复,所以判断成员是否存在的成本是 O(n),只适合小型、读多写少的集合。
Set<Listener> listeners = new CopyOnWriteArraySet<>();
元素很多、需要频繁并发判断成员时,用 ConcurrentHashMap.newKeySet()。
10. 常见问题
10.1 读操作成本
get 只需读数组引用、再按索引取元素,成本是 O(1)。引用在数组里连续存放,CPU 缓存可以连续读取,也就是缓存局部性好。但读得快不等于读得新:迭代器固定在旧数组上,业务要能接受看到旧的列表内容。
10.2 迭代器的只读约束
迭代器拿的是旧数组,而容器此时可能已经指向另一个数组了。在旧快照上做的修改很难合并回当前版本,所以迭代器被设计成只读。要修改当前列表,调用容器自己的方法。
10.3 旧数组的回收时机
旧数组要等所有强引用都消失后才能被 GC 回收。只要还有迭代器持有它,数组和它引用的元素就会一直存活。如果写入频繁、迭代器又被长期保存,好几个大数组版本会同时占着内存。
10.4 CopyOnWriteArrayList 与同步列表
两者把成本放在了不同的地方。CopyOnWrite 的主要成本在写入,遍历时不用持锁,但要保留旧数组。synchronizedList 是给列表的每个方法加锁的包装器,更新时不需要复制整个数组;可是遍历时要一直持有包装对象的锁,其他使用同一把锁的更新只能等着。选择时要结合写入频率、列表大小和是否需要快照语义。
11. 面试题卡片
12. 参考资料
来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明