CopyOnWriteArrayList 底层原理:从"写时复制"到源码细节

面向 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();
    }
}

五步走:

  1. 加锁
  2. 取旧数组
  3. Arrays.copyOf 复制出一个长度 +1 的新数组
  4. 在新数组上写入新元素
  5. 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",而是一个在特定负载形状(读极多、写极少、列表可控)下才正确的并发取舍。

相关推荐
nice_lcj52015 天前
Java 并发容器入门:ConcurrentHashMap、CopyOnWriteArrayList、阻塞队列
java·面试·并发编程·阻塞队列·concurrenthashmap·copyonwritearraylist