跳到主要内容
约 8 分钟3 张卡

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. 写入与数组复制​

写操作必须防止多个线程同时基于同一个旧数组修改,否则后发布的新数组会覆盖前一次的修改。所以加入元素时,要在写锁的保护下依次完成:

  1. 获取写锁。
  2. 读取当前数组。
  3. 分配一个长度加一的新数组。
  4. 复制旧数组的引用,再写入新元素。
  5. 发布新数组的引用。

删除成功,或者把某个位置替换成不同的引用时,同样要复制数组:

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 旧数组的回收时机​

10.4 CopyOnWriteArrayList 与同步列表​

11. 面试题卡片​

12. 参考资料​

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