CopyOnWriteArrayList源码分析

基于jdk1.7源码

一、无锁容器

CopyOnWriteArrayList是JDK5中添加的新的容器，除此之外，还有CopyOnWriteArraySet、ConcurrentHahshMap和ConcurrentLinkedQueue等，它们都是无锁容器。

所谓无锁，就是不需要使用对象内置锁(synchronized)或显示加锁(Lock),而是抛弃锁机制而使用其它一些策略来保证线程安全。

这些无锁容器背后的通用策略是：对容器的修改可以与读取操作同时发生，只要读取者只能看完成修改的结果即可。修改是在容器数据结构的某个部分的一个单独的副本(有时是整个数据结构的副本)上执行的，并且这个副本在修改过程中是不可视的。只有当修改完成时，被修改的结构才会自动地与主数据结构进行交换，之后读取者就可以看到这个修改了。

——from《java编程思想》p755

二、源码分析

类声明

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

属性

    /** The lock protecting all mutators */
    /** 重入锁*/
    transient final ReentrantLock lock = new ReentrantLock();

    /** The array, accessed only via getArray/setArray. */
    /** 数组，只能通过getArray/setArray访问*/
    private volatile transient Object[] array;

构造器

    /**
     * 构造器(构造一个空的数组)
     */
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }

    /**
     * 构造器(使用指定的容器来创建，按照原容器中元素的顺序)。
     */
    public CopyOnWriteArrayList(Collection<? extends E> c) {
        Object[] elements = c.toArray();
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        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));
    }

CopyOnWriteArrayList在创建时，并没有默认容量，这点跟ArrayList不同。

get方法

    public E get(int index) {
        return get(getArray(), index);
    }

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

读操作没有进行同步，因为CopyOnWriteArrayList的读和写分离。

add方法

    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        //使用重入锁加锁
        lock.lock();
        try {
            //现有数组
            Object[] elements = getArray();
            int len = elements.length;
            //创建新数组，并扩容1，用现有数组元素来填充(末尾为空)
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            //将当前元素添加到数组尾部(在新数组上操作)
            newElements[len] = e;

            setArray(newElements);
            return true;
        } finally {
            //释放锁
            lock.unlock();
        }
    }
 

remove方法

    public boolean remove(Object o) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            if (len != 0) {
                // Copy while searching for element to remove
                // This wins in the normal case of element being present
                int newlen = len - 1;//新数组长度比原来少1
                //构建新数组
                Object[] newElements = new Object[newlen];

                //遍历查找现有数组【不包含末位元素】
                for (int i = 0; i < newlen; ++i) {
                    //若存在
                    if (eq(o, elements[i])) {
                        // found one;  copy remaining and exit
                        //将待删除元素o的后续所有元素拷贝到新数组中【拷贝o后面所有元素】
                        for (int k = i + 1; k < len; ++k)
                            newElements[k-1] = elements[k];

                        setArray(newElements);
                        return true;
                    } else
                        //当前不是要找的目标元素o，顺便将元素拷贝到新数组中【多次循环累计的这个操作相当于拷贝目标元素之前位置的所有元素】
                        //【由此说明，即使不存在目标元素，依然要做拷贝现有数组的操作】
                        newElements[i] = elements[i];
                }

                // special handling for last cell
                //【末位元素单独处理】
                //如果末位元素是目标元素。此时，该拷贝的元素都已拷贝到新数组中，直接setArray(newElements)
                if (eq(o, elements[newlen])) {
                    setArray(newElements);
                    return true;
                }
                //如果末位元素仍然不是目标元素，说明不存在目标元素。
                //因为没有setArray(newElements),所以原数组依旧是原数组。

            }

            //现有元素数组为空，直接返回false
            return false;
        } finally {
            lock.unlock();
        }
    }

迭代器

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

    private static class COWIterator<E> implements ListIterator<E> {

        //快照数组
        private final Object[] snapshot;
        private int cursor;

        private COWIterator(Object[] elements, int initialCursor) {
            cursor = initialCursor;
            //
            snapshot = elements;
        }

        public boolean hasNext() {
            return cursor < snapshot.length;
        }

        public boolean hasPrevious() {
            return cursor > 0;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            if (! hasNext())
                throw new NoSuchElementException();
            //
            return (E) snapshot[cursor++];
        }

        @SuppressWarnings("unchecked")
        public E previous() {
            if (! hasPrevious())
                throw new NoSuchElementException();
            //
            return (E) snapshot[--cursor];
        }

        public int nextIndex() {
            return cursor;
        }

        public int previousIndex() {
            return cursor-1;
        }

        /**
         * 迭代器不支持remove/set/add方法。
         */
        public void remove() {
            throw new UnsupportedOperationException();
        }
        public void set(E e) {
            throw new UnsupportedOperationException();
        }
        public void add(E e) {
            throw new UnsupportedOperationException();
        }
    }

总结

1.CopyOnWriteArrayList的工作原理？

CopyOnWriteArrayList在做修改操作时，每次都是重新创建一个新的数组，在新数组上操作，最终再将新数组替换掉原数组。因此，在做修改操作时，仍可以做读取操作，读取直接操作的原数组。读和写操作的目标都不同，因此读操作和写操作互不干扰，只有写与写之间需要进行同步等待。另外，原数组被声明为volatile，这就保证了，一旦数组发生变化，则结果对其它线程(读线程和其它写线程)是可见的。

2.CopyOnWriteArrayList适合的应用场景？

正是由于每次修改都会创建新数组，内存中都要同时存有原数组和新数组，同时也要将元素拷贝到新数组中，内存开销大，所以CopyOnWriteArrayList只适合于读多写少的场景。

比如某些系统级别的信息，往往只是需要加载或者修改很少的次数，但是会被系统内所有模块频繁的访问，对于这种场景，我们最希望看到的就是读操作尽可能地快，而写即使慢一些也没太大关系。

3.CopyOnWriteArrayList能否像ArrayList一样支持fail-fast？

CopyOnWriteArrayList并不支持fail-fast机制，所以不会抛出ConcurrentModificationException，也不必编写特殊的代码去防范这种异常。

4.CopyOnWriteArrayList的扩容 

CopyOnWriteArrayList并不像ArrayList一样指定默认的初始容量。它也没有自动扩容的机制，而是添加几个元素，长度就相应的增长多少。

①因为CopyOnWriteArrayList适用于读多写少，既然是写的情况少，则不需要频繁扩容。

②修改操作每次在生成新的数组时就指定了新的容量，也就相当于扩容了，所以不需要额外的机制来实现扩容。