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. 适合频繁访问，极少修改的情况下使用