面向 Java 进阶与面试复习,按"问题 → 结构 → 读 → 写 → 迭代器 → 验证 → 边界 → 面试"的顺序由浅入深展开。
目录
- 一、先搞清楚它解决什么问题
- 二、两个核心字段撑起整个设计
- 三、读为什么完全不加锁
- [四、写操作:锁 + 复制 + 替换](#四、写操作:锁 + 复制 + 替换)
- [五、迭代器:快照 + 弱一致性](#五、迭代器:快照 + 弱一致性)
- 六、可运行验证代码
- 七、代价与适用边界
- 八、常见面试考点与参考答案
一、先搞清楚它解决什么问题
ArrayList 线程不安全,多线程写会丢数据甚至抛出异常;Vector 和 Collections.synchronizedList 虽然安全,但每次读写都要抢同一把锁,读多写少的场景下读线程被白白阻塞。
CopyOnWriteArrayList 的思路是读写分离:读操作完全不加锁,直接读当前数组;写操作也不阻塞正在进行的读,而是先复制一份新数组,在新数组上修改,改完后把底层数组引用一次性切换到新数组。正在读旧数组的线程继续安全地读,写线程也不影响它们------两边各看各的,互不干涉。
这个策略的名字就叫 Copy-On-Write(写时复制,COW)。代价也很直接:每次写都全量复制数组,写多的时候性能和内存都会急剧恶化;读到的数据也不保证是最新的,只能做到最终一致。
二、两个核心字段撑起整个设计
CopyOnWriteArrayList 的内部结构极其精简,只有两个关键字段:
java
public class CopyOnWriteArrayList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
/** 保护所有写操作的锁 */
final transient ReentrantLock lock = new ReentrantLock();
/** 底层数组,只能通过 getArray / setArray 访问 */
private transient volatile Object[] array;
final Object[] getArray() { return array; }
final void setArray(Object[] a) { array = a; }
}
lock是写操作的互斥锁,保证同一时刻只有一个线程在执行"复制---修改---替换"。array是volatile的,这是读操作可以完全不加锁的前提:一个线程通过setArray把新数组发布出去之后,其他线程通过getArray做一次 volatile 读,一定能看到这个新数组引用,以及写线程在发布之前对新数组所做的全部写入。
三、读为什么完全不加锁
get 和 iterator 的读路径都极短:
java
public E get(int index) {
return get(getArray(), index);
}
private E get(Object[] a, int index) {
return (E) a[index];
}
getArray() 只是一次 volatile 读,拿到当前数组引用后直接下标访问,没有任何锁、CAS 或同步块。这也意味着读操作和写操作可以真正并行:写线程在复制和修改新数组,读线程在旧数组上读,彼此不阻塞。
在 90% 读、10% 写的负载下,这种无锁读的吞吐通常明显高于读写锁方案。
四、写操作:锁 + 复制 + 替换
4.1 add 的完整路径
java
public boolean add(E e) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
Object[] newElements = Arrays.copyOf(elements, len + 1);
newElements[len] = e;
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}
五步走:
- 加锁
- 取旧数组
Arrays.copyOf复制出一个长度 +1 的新数组- 在新数组上写入新元素
setArray发布新数组并解锁
注意 :
Arrays.copyOf底层是System.arraycopy,对引用类型数组是浅拷贝------复制的是元素引用,不是元素对象本身。因此如果 List 里存的是可变对象,新数组和旧数组共享同一批元素对象,对元素内部状态的修改不会被 COW 隔离。
4.2 remove 和 set 的一个容易忽略的细节
remove 同样先复制再在新数组上删除,然后 setArray。
set 有一个特殊之处:当新值和旧值相等(oldValue == element 对引用类型,或者 equals)时,它仍然会调用 setArray,即使数组内容根本没有变。
这个"看似多余"的调用是为了保证一个不变式:set 在任何情况下都执行一次对 array 的 volatile 写。 如果某些情况下 set 走 volatile 写、另一些情况不走,那么依赖"volatile 写 happens-before 后续 volatile 读"的可见性保证就会变得依赖运行时数据,这在 Java 内存模型下是不可接受的。统一执行 volatile 写,才能保证:写线程在 set 之前对其他非 volatile 字段的写入,对随后通过 get 读到新值的线程一定可见。
五、迭代器:快照 + 弱一致性
CopyOnWriteArrayList.iterator() 返回的 COWIterator 在构造时做了一件事:把当前的 array 引用保存到 snapshot 字段中。
注意:它保存的是引用,不是数组副本------因为 COW 的写操作永远不会修改旧数组,旧数组在迭代器生命周期内是天然不可变的。
由此得到几个关键行为:
| 行为 | 说明 |
|---|---|
不抛 ConcurrentModificationException |
迭代器只读自己的 snapshot,写线程复制新数组、替换引用,与迭代器无关 |
| 看不到迭代期间的新增/删除 | 快照定格在创建迭代器的那一刻,之后 List 的任何变化都不会反映到这次遍历中 |
迭代器自身 remove/set/add 不支持 |
调用抛 UnsupportedOperationException |
这种"不反映最新修改、但保证遍历期间数组不变"的一致性,就是弱一致性。它不是 bug,而是 COW 设计的直接结果:用"读到的可能不是最新"换取"读永远不阻塞、迭代永远不抛异常"。
六、可运行验证代码
以下代码可以直接放到 main 方法中运行,覆盖快照迭代、并发写不阻塞读、写写互斥三个核心行为。
java
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
public class CowDemo {
public static void main(String[] args) throws Exception {
snapshotIteratorDemo();
concurrentReadWriteDemo();
writeSerializationDemo();
}
/** 验证:迭代器是快照,遍历期间不反映后续写入 */
static void snapshotIteratorDemo() {
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
list.add("A");
list.add("B");
Iterator<String> it = list.iterator();
list.add("C"); // 迭代器创建后再写
list.remove("A"); // 再删
System.out.println("=== 快照迭代器 ===");
System.out.print("迭代器看到的元素: ");
while (it.hasNext()) {
System.out.print(it.next() + " "); // 只输出 A B
}
System.out.println();
System.out.println("迭代结束后 List 实际内容: " + list); // [B, C]
// 迭代器的 remove 不支持
Iterator<String> it2 = list.iterator();
it2.next();
try {
it2.remove();
} catch (UnsupportedOperationException e) {
System.out.println("迭代器 remove 抛出 UnsupportedOperationException(符合预期)");
}
}
/** 验证:写线程在复制/修改时,读线程仍然可以无锁读取旧数组 */
static void concurrentReadWriteDemo() throws Exception {
CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<>();
for (int i = 0; i < 1000; i++) list.add(i);
ExecutorService pool = Executors.newFixedThreadPool(2);
CountDownLatch start = new CountDownLatch(1);
AtomicInteger readCount = new AtomicInteger();
AtomicInteger writeCount = new AtomicInteger();
pool.submit(() -> {
try { start.await(); } catch (InterruptedException ignored) {}
Iterator<Integer> it = list.iterator(); // 拿到快照
while (it.hasNext()) {
it.next();
readCount.incrementAndGet();
}
});
pool.submit(() -> {
try { start.await(); } catch (InterruptedException ignored) {}
for (int i = 0; i < 1000; i++) {
list.add(10000 + i); // 写不阻塞上面的读
writeCount.incrementAndGet();
}
});
start.countDown();
pool.shutdown();
pool.awaitTermination(5, TimeUnit.SECONDS);
System.out.println("\n=== 并发读写 ===");
System.out.println("读线程遍历元素数(快照长度): " + readCount.get()); // 1000
System.out.println("写线程新增元素数: " + writeCount.get()); // 1000
System.out.println("最终 List 大小: " + list.size()); // 2000
}
/** 验证:写写互斥,最终 size 与写入次数一致,不会丢写 */
static void writeSerializationDemo() throws Exception {
CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<>();
int threads = 8;
int perThread = 500;
ExecutorService pool = Executors.newFixedThreadPool(threads);
CountDownLatch latch = new CountDownLatch(threads);
for (int t = 0; t < threads; t++) {
final int base = t * perThread;
pool.submit(() -> {
for (int i = 0; i < perThread; i++) list.add(base + i);
latch.countDown();
});
}
latch.await();
pool.shutdown();
System.out.println("\n=== 并发写写 ===");
System.out.println("预期 size: " + (threads * perThread)); // 4000
System.out.println("实际 size: " + list.size()); // 4000
}
}
运行结果解读 :快照迭代器只看到 A B,List 实际已是 [B, C];读线程遍历的仍是创建迭代器时的 1000 个元素,写线程并行完成了 1000 次新增,互不阻塞;8 个线程并发写后 size 精确为 4000,说明写写被 ReentrantLock 正确串行化。
七、代价与适用边界
| 维度 | 说明 |
|---|---|
| 写性能 | 每次写都要 Arrays.copyOf 全量复制,时间复杂度 O(n) ,且持有锁期间完成复制和写入。有测试数据显示,在一万级元素规模下,ArrayList 追加操作通常在亚毫秒级,而 CopyOnWriteArrayList 可能达到数十毫秒量级。列表越大、写越频繁,差距越夸张 |
| 内存 | 写操作期间旧数组和新数组同时存在,瞬时内存约为原来的 2 倍。如果元素本身是大对象,频繁写容易触发 GC 压力 |
| 一致性 | 只保证最终一致 。一个线程写入后,另一个线程如果已经持有旧数组引用或旧迭代器,它读到的仍然是旧数据,直到下一次 getArray / 新迭代器才可能看到新值 |
适用场景:读操作远多于写操作,且列表规模不宜过大------典型如配置项列表、监听器注册表、白名单等"启动时或低频写入、运行期高频遍历"的结构。
不适用场景 :写密集型场景应转向 ConcurrentHashMap 的 keySet 视图、Collections.synchronizedList 配合合适粒度的同步,或读写锁方案。
八、常见面试考点与参考答案
Q1:CopyOnWriteArrayList 的"写时复制"具体指什么?
写操作(add / remove / set)不直接修改底层数组,而是先获取 ReentrantLock,用 Arrays.copyOf 复制出一个新数组,在新数组上完成修改,最后通过 setArray 把 array 引用指向新数组并释放锁。旧数组保持不变,正在读它的线程继续安全读取。
Q2:读操作为什么不需要加锁?volatile 在这里起什么作用?
读路径只做一次 getArray()(volatile 读)然后下标访问。array 被 volatile 修饰,保证写线程通过 setArray 发布新数组后,读线程下一次 volatile 读一定能看到新引用,并且能看到写线程在发布之前对新数组的所有写入。没有 volatile,读线程可能永远看不到新数组或看到"半成品"状态。
Q3:迭代器为什么不会抛 ConcurrentModificationException?它是强一致的吗?
COWIterator 在创建时把当前 array 引用保存为 snapshot。由于 COW 写操作从不修改旧数组,迭代器在遍历期间看到的数组是天然不可变的,不存在"遍历中被修改"的情况,所以不会抛 CME。但它只能看到创建迭代器那一刻的数据,之后 List 的任何变化都不反映,因此是弱一致,不是强一致。
Q4:set 方法在 oldValue == element 时为什么还要调用 setArray?
为了在所有执行路径上都建立"set 必然执行一次 volatile 写 array"的不变式。如果某些情况下不写 array,那么依赖 volatile 写-读的 happens-before 可见性保证就会因运行时数据不同而时有时无。统一 setArray 才能保证写线程在 set 之前的其他写入,对随后通过 get 读到新值的线程一定可见。
Q5:CopyOnWriteArrayList 和读写锁(ReentrantReadWriteLock)相比,怎么选?
两者都是读写分离,但粒度不同。读写锁的读锁是共享的、写锁是排他的,读读不互斥、读写互斥;COW 的读完全无锁,写通过复制新数组来避免阻塞读,代价是写开销 O(n) 且内存翻倍。
- 读极多写极少且列表不大 → COW 的无锁读优势明显
- 写有一定频率或列表较大 → 读写锁或同步容器更合适,因为写不会每次都全量复制
Q6:COW 的"最终一致性"会导致什么实际使用陷阱?
典型陷阱是"写完立刻在另一个线程读"------由于读线程可能仍持有旧数组引用,它读不到刚写入的数据。更隐蔽的是迭代期间的修改:在 COW 上遍历时删除元素不会抛异常,但遍历看到的仍是旧快照,删除效果在当前遍历中完全不可见,容易写出逻辑上"删了但还在遍历"的代码。
总结
CopyOnWriteArrayList的本质是:用写时的 O(n) 复制和双倍内存峰值,换取读路径的完全无锁和迭代的绝对安全。它不是一个"更快的 ArrayList",而是一个在特定负载形状(读极多、写极少、列表可控)下才正确的并发取舍。