CopyOnWriteArrayList源码分析

CopyOnWriteArrayList

源码基于1.8.0_112

CopyOnWriteArrayList也是通过数组来存储元素，阅读过之前的ArrayList的话这边应该很容易理解

原理 ：CopyOnWriteArrayList内部通过数组来存储数据，每次修改list都会产生一个新的数组，然后复制原始数据。修改方法都通过内部的而一个锁对象来实现同步。如果一个线程修改操作进行了一半，另外一个线程来读取集合，则它读取的是修改前的数组，不会产生同步异常。CopyOnWriteArrayList进行迭代遍历的时候，会保存一份快照，然后对这份快照进行遍历，这种机制称为安全失败（fail-safe）。

成员变量

大致浏览，结合具体方法来了解具体含义

    // 锁对象    final transient ReentrantLock lock = new ReentrantLock();    // 存储数据的数组，只提供给get和set方法访问    private transient volatile Object[] array;

构造方法

先阅读默认构造函数，其他构造函数可在阅读完具体操作后再回来阅读

    /**     * 创建一个空的集合     */    public MyCopyOnWriteArrayList() {        // 设置一个空数组        setArray(new Object[0]);    }    // 设置数组    final void setArray(Object[] a) {        array = a;    }

add(E e)

每次加入数据都会新建一个数组，性能较差
加入数据时会新建一个原本数组长度+1的数组，然后复制到新数组中，最后在末尾赋值

代码

    /**     * 添加对象     */    public boolean add(E e) {        // 成员锁对象，和synchronized具有相同的功能，ReentrantLock的功能更加的丰富        final ReentrantLock lock = this.lock;        // 加锁，每次只有一个线程可进入临界区        lock.lock();        try {            // 拿到存储对象的数组            Object[] elements = getArray();            int len = elements.length;            // 把原来的的数组复制到一个比原本长度大1位的数组中            // 如：A,B,C,D,E ---> A,B,C,D,E,NULL            Object[] newElements = Arrays.copyOf(elements, len + 1);            // 加入新的值            // 如：A,B,C,D,E,NULL ---> A,B,C,D,E,F            newElements[len] = e;            // 设置数组            setArray(newElements);            return true;        } finally {            // 最后解锁            lock.unlock();        }    }    // 设置数组    final void setArray(Object[] a) {        array = a;    }    // 获取数组    final Object[] getArray() {        return array;    }

get(int index)

很简单的方法，不解释

代码

    /**     * 随机访问     */    public E get(int index) {        return get(getArray(), index);    }    @SuppressWarnings("unchecked")    private E get(Object[] a, int index) {        return (E) a[index];    }

remove(int index)

把不需要删除的数据复制到一个新的数组中

图解

代码

       /**     * 删除元素     */    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;            // 移除的是最后一个元素            // 如：A,B,C,D,E ---> A,B,C,D            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();        }    }

iterator()

简单分析iterator
迭代访问的是原始数据的一份快照

    // 对快照进行遍历    public COWIterator<E> iterator() {        return new MyCopyOnWriteArrayList.COWIterator<E>(getArray(), 0);    }    static final class COWIterator<E> {        // 快照        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;        }        @SuppressWarnings("unchecked")        public E next() {            if (! hasNext())                throw new NoSuchElementException();            // 对快照进行访问            return (E) snapshot[cursor++];        }    }

总结

1. CopyOnWriteArrayList为线程安全的集合类
2. 随机访问不需要同步，所以访问速度很快
3. 修改操作会拷贝数组，性能很差
4. 适合频繁访问，极少修改的情况下使用