Java并发Concurrent包——CopyOnWriteArrayList源码分析

CopyOnWriteArrayList 和 ArrayList 比较相似，只不过 CopyOnWriteArrayList 是线程安全的。
当进行写操作时，将原来的数组复制一份新的数组，写操作在这个新数组上进行；此时不影响旧数组上的读操作。写操作完成后，数组的引用改为新的数组即可，旧数组不再使用。

属性

    // 锁对象
    final transient ReentrantLock lock = new ReentrantLock();

    // 底层数组
    private transient volatile Object[] array;

底层数组 array 只能通过 getArray() 和 setArray() 方法来访问和设置。

    final Object[] getArray() {
        return array;
    }

    // 设置底层数组为给定数组
    final void setArray(Object[] a) {
        array = a;
    }

构造函数

    // 创建一个空列表
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }

    // 根据给定集合来创建列表
    public CopyOnWriteArrayList(Collection c) {
        Object[] elements;
        if (c.getClass() == CopyOnWriteArrayList.class)
            elements = ((CopyOnWriteArrayList)c).getArray();
        else {
            elements = c.toArray();
            if (elements.getClass() != Object[].class)
                elements = Arrays.copyOf(elements, elements.length, Object[].class);
        }
        setArray(elements);
    }

    // 根据给定数组来创建列表
    public CopyOnWriteArrayList(E[] toCopyIn) {
        setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
    }

重要方法

对于读的方法就不需要再看了，和 ArrayList 区别不大，主要来看写操作：

set(int index, E element)

    public E set(int index, E element) {
        final ReentrantLock lock = this.lock;
        // 写操作必须加锁，否则多个线程同时执行，会copy出很多新数组
        lock.lock();
        try {
            Object[] elements = getArray();
            // 保存当前数组index下标处的旧对象
            E oldValue = get(elements, index);

            if (oldValue != element) {
                // 设置新对象
                int len = elements.length;
                // 新数组，对原数组的完全拷贝
                Object[] newElements = Arrays.copyOf(elements, len);
                // 更新index下标的对象
                newElements[index] = element;
                // 设置新数组为底层数组
                setArray(newElements);
            } else {
                // Not quite a no-op; ensures volatile write semantics
                // 这里虽然没有变化，但是并不完全是一个空操作，而是要保证volatile的语义
                // 线程中将一个对象放入任何并发collection之前的操作happen-before从另一线程中的collection访问或移除该元素的后续操作。 
                // 如果线程1写入了volatile变量v，接着线程2读取了v，那么，线程1写入v及之前的写操作都对线程2可见
                // 这里就是让volatile修饰的寄存器中的旧值失效，从内存中重新读取，保证写操作的可见性
                setArray(elements);
            }
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

add(E e)

添加一个新元素，也是加锁，然后复制一个长度多 1 的新数组，将新元素放入新数组最后下标中。

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

remove(int index)

删除操作，也是加锁后，复制新数组，长度为减 1 的长度，然后以删除下标分为两部分来复制。

    public E remove(int index) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            E oldValue = get(elements, index);
            int numMoved = len - index - 1;
            if (numMoved == 0)
                setArray(Arrays.copyOf(elements, len - 1));
            else {
                Object[] newElements = new Object[len - 1];
                System.arraycopy(elements, 0, newElements, 0, index);
                System.arraycopy(elements, index + 1, newElements, index,
                                 numMoved);
                setArray(newElements);
            }
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

CopyOnWriteArraySet

另外，还有一个相似的类， CopyOnWriteArraySet 。

    private final CopyOnWriteArrayList al;

    public CopyOnWriteArraySet() {
        al = new CopyOnWriteArrayList();
    }

通过源码可以知道 CopyOnWriteArraySet 包含 CopyOnWriteArrayList 对象，它是通过 CopyOnWriteArrayList 实现的。
CopyOnWriteArrayList 中允许有重复的元素；CopyOnWriteArraySet 不能有重复。因此，CopyOnWriteArrayList 额外提供了 addIfAbsent() 和 addAllAbsent() 这两个添加元素的 API ，通过这些 API 来添加元素时，只有当元素不存在时才执行添加操作。