CopyOnWriteArrayList源码分析

一、CopyOnWrite容器

       CopyOnWrite容器即写时复制的容器。通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

二、CopyOnWriteArrayList

       CopyOnWriteArrayList是ArrayList线程安全的集合，其中所有可变操作（add、set）都是通过对底层数组进行一次新的复制来实现的。

      CopyOnWriteArrayList绝对不会抛出ConcurrentModificationException的异常。因为该列表在遍历时将不会被做任何的修改。

       CopyOnWriteArrayList适合用在“读多，写少”的“并发”应用中，换句话说，它适合使用在读操作远远大于写操作的场景里，比如缓存。它不存在“扩容”的概念，每次写操作（add or remove）都要copy一个副本，在副本的基础上修改后改变array引用，所以称为“CopyOnWrite”，因此在写操作是加锁，并且对整个list的copy操作时相当耗时的，过多的写操作不推荐使用该存储结构。

三 、 实现原理

      add方法的实现（向CopyOnWriteArrayList里添加元素），可以发现在添加的时候是需要加锁的，否则多线程写的时候会Copy出N个副本出来。

 /**     * Appends the specified element to the end of this list.     *     * @param e element to be appended to this list     * @return {@code true} (as specified by {@link Collection#add})     */    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();        }    }

public E set(int index, E element) {        final ReentrantLock lock = this.lock;        lock.lock();        try {            Object[] elements = getArray();            E oldValue = get(elements, index);            if (oldValue != element) {                int len = elements.length;                Object[] newElements = Arrays.copyOf(elements, len);                newElements[index] = element;                setArray(newElements);            } else {                // Not quite a no-op; ensures volatile write semantics                setArray(elements);            }            return oldValue;        } finally {            lock.unlock();        }    }

类的内部类

　　COWIterator类　　

static final class COWIterator<E> implements ListIterator<E> {        /** Snapshot of the array */        // 快照        private final Object[] snapshot;        /** Index of element to be returned by subsequent call to next.  */        // 游标        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;        }        // next项        @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;        }        /**         * Not supported. Always throws UnsupportedOperationException.         * @throws UnsupportedOperationException always; {@code remove}         *         is not supported by this iterator.         */        // 不支持remove操作        public void remove() {            throw new UnsupportedOperationException();        }        /**         * Not supported. Always throws UnsupportedOperationException.         * @throws UnsupportedOperationException always; {@code set}         *         is not supported by this iterator.         */        // 不支持set操作        public void set(E e) {            throw new UnsupportedOperationException();        }        /**         * Not supported. Always throws UnsupportedOperationException.         * @throws UnsupportedOperationException always; {@code add}         *         is not supported by this iterator.         */        // 不支持add操作        public void add(E e) {            throw new UnsupportedOperationException();        }        @Override        public void forEachRemaining(Consumer<? super E> action) {            Objects.requireNonNull(action);            Object[] elements = snapshot;            final int size = elements.length;            for (int i = cursor; i < size; i++) {                @SuppressWarnings("unchecked") E e = (E) elements[i];                action.accept(e);            }            cursor = size;        }    }

　　说明：COWIterator表示迭代器，其也有一个Object类型的数组作为CopyOnWriteArrayList数组的快照，这种快照风格的迭代器方法在创建迭代器时使用了对当时数组状态的引用。此数组在迭代器的生存期内不会更改，因此不可能发生冲突，并且迭代器保证不会抛出 ConcurrentModificationException。创建迭代器以后，迭代器就不会反映列表的添加、移除或者更改。在迭代器上进行的元素更改操作（remove、set 和 add）不受支持。这些方法将抛出 UnsupportedOperationException。

读的时候不需要加锁，如果读的时候有多个线程正在向CopyOnWriteArrayList添加数据，读还是会读到旧的数据，因为写的时候不会锁住旧的CopyOnWriteArrayList。

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

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

缺点：

      1、内存占用问题。因为CopyOnWrite的写时复制机制，所以在进行写操作的时候，内存里会同时驻扎两个对象的内存，旧的对象和新写入的对象（注意:在复制的时候只是复制容器里的引用，只是在写的时候会创建新对象添加到新容器里，而旧容器的对象还在使用，所以有两份对象内存）。如果这些对象占用的内存比较大

     2、数据一致性问题。CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。所以如果你希望写入的的数据，马上能读到，请不要使用CopyOnWrite容器。

参考文章：

     http://www.cnblogs.com/dolphin0520/p/3938914.html