概述

一种线程安全的 ArrayList，其中所有的修改操作都是通过生成底层数组的副本来实现的。虽然这种成本较高，但对于遍历操作较多，写并发较小的场景，使用这个并发集合会非常合适。快照模式能保证所创建的迭代器，在迭代器的生命周期内数据永远不会发生更改。

重要的变量

// java.util.concurrent.CopyOnWriteArrayList
public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    // CopyOnWriteArrayList 全局变量锁，所有的变更操作都需要先获得这把锁
    final transient ReentrantLock lock = new ReentrantLock();
    // 存放数据的数组
    private transient volatile Object[] array;
    ...
}

变量非常少，只有两个，一个用于存放数据，另一个就是全局锁。在所有的修改操作在执行前，都需要获得这把锁。

构造函数

public CopyOnWriteArrayList() {
    setArray(new Object[0]);
}
public CopyOnWriteArrayList(Collection<? extends E> c) {
    Object[] elements;
    if (c.getClass() == CopyOnWriteArrayList.class)
        elements = ((CopyOnWriteArrayList<?>)c).getArray();
    else {
        elements = c.toArray();
        if (c.getClass() != ArrayList.class)
            elements = Arrays.copyOf(elements, elements.length, Object[].class);
    }
    setArray(elements);
}
public CopyOnWriteArrayList(E[] toCopyIn) {
    setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
}

CopyOnWriteArrayList 默认的数组初始化长度为 0。

源码解析

添加操作：add

// java.util.concurrent.CopyOnWriteArrayList#add(E)
public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        // #1 复制数组，长度 + 1
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        // #2 修改指针
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

获取迭代器：iterator

public Iterator<E> iterator() {
    return new COWIterator<E>(getArray(), 0);
}

快照：COWIterator

static final class COWIterator<E> implements ListIterator<E> {
    /** Snapshot of the array */
    private final Object[] snapshot;

    // 遍历游标
    private int cursor;

    // 构造函数
    private COWIterator(Object[] elements, int initialCursor) {
        cursor = initialCursor;
        snapshot = elements;
    }    
    ...
}

这里建立的快照就是保存对原数组的引用，原数组肯定是不会修改的。因为修改操作会重新创建一个新的数组。