CopyOnWriteArrayList源码解读

一、概述

        Copy-On-Write简称COW，是一种用于集合的并发访问的优化策略。

        基本思想是：当我们往一个集合容器中写入元素时（添加、修改、删除），并不会直接在集合容器中写入，而是先将当前集合容器进行Copy，复制出一个新的容器，然后新的容器里写入元素，写入操作完成之后，再将原容器的引用指向新的容器。

        CopyOnWriteArrayList相当于线程安全的ArrayList，内部存储结构采用Object[]数组，线程安全使用ReentrantLock实现，允许多个线程并发读取，但只能有一个线程写入。

二、lock

        使用final、transient关键字声明了ReentrantLock可重用锁。保证ReentrantLock不可变性和不被序列化，保证线程安全。

final transient ReentrantLock lock = new ReentrantLock();

三、array

        使用数组存储数据，使用volatile修饰变量，保证了数据的可见性，以及一个线程更新了数据以后确保另一个线程可以知道。

private transient volatile Object[] array;

四、get()方法

private E get(Object[] a, int index) {
        return (E) a[index];
    }

    
public E get(int index) {
        //根据指定下标，从原数组中读取元素
        return get(getArray(), index);
    }

五、set()方法

public E set(int index, E element) {
        final ReentrantLock lock = this.lock;
        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);
                //将索引位置元素替换成传进来的元素
                newElements[index] = element;
                setArray(newElements);
            } else {
                setArray(elements);
            }
            //一致则返回元素
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

六、add()方法

        添加新元素至集合时，会将当前数组Copy到新的数组，并将新元素添加至新数组，最后替换原数组。执行过程中，使用ReentrantLock加锁，保证了线程安全，避免多个线程复制数组。

public boolean add(E e) {
        //ReentrantLock加锁，保证写操作的原子性
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {

            //getArray()方法是获取到内部维护的数组
            Object[] elements = getArray();

            //获取到长度
            int len = elements.length;

            //复制出新数组
            Object[] newElements = Arrays.copyOf(elements, len + 1);

            //把新元素添加到新的数组里面
            newElements[len] = e;

            //把原数组引用指向新数组
            setArray(newElements);
            return true;
        } finally {
            //解锁
            lock.unlock();
        }
    }

七、add()重载方法

public void add(int index, E element) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;

            //判断规定的索引位置是否超过数组长度
            if (index > len || index < 0)
                //超过就抛异常
                throw new IndexOutOfBoundsException("Index: "+index+", Size: "+len);
            Object[] newElements;
            int numMoved = len - index;
            //判断是否是数组长度最后一位的索引
            if (numMoved == 0)
                //通过Arrays工具类的copyOf()方法复制出一个新的数组，并且长度+1
                newElements = Arrays.copyOf(elements, len + 1);
            else {
                newElements = new Object[len + 1];
                System.arraycopy(elements, 0, newElements, 0, index);
                System.arraycopy(elements, index, newElements, index + 1,numMoved);
            }
            newElements[index] = element;
            setArray(newElements);
        } finally {
            lock.unlock();
        }
    }

八、remove()方法

        删除指定下标元素。根据指定下标，从原数组中Copy其他元素至新数组，最后替换原数组。

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

九、addAll()方法

public boolean addAll(Collection<? extends E> c) {
        //取到对应的元素们
        Object[] cs = (c.getClass() == CopyOnWriteArrayList.class) ?
            ((CopyOnWriteArrayList<?>)c).getArray() : c.toArray();
        if (cs.length == 0)
            return false;
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            //如果原数组长度为0，且集合是ArrayList或CopyOnWriteArrayList，直接赋值
            if (len == 0 && cs.getClass() == Object[].class)
                setArray(cs);
            //否则，在尾部追加这些元素
            else {
                Object[] newElements = Arrays.copyOf(elements, len + cs.length);
                System.arraycopy(cs, 0, newElements, len, cs.length);
                setArray(newElements);
            }
            return true;
        } finally {
            lock.unlock();
        }
    }

十、removeAll()方法

//删除位于集合c里的元素
public boolean removeAll(Collection<?> c) {
        if (c == null) throw new NullPointerException();
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            if (len != 0) {
                // temp array holds those elements we know we want to keep
                int newlen = 0;
                Object[] temp = new Object[len];
                for (int i = 0; i < len; ++i) {
                    Object element = elements[i];
                    if (!c.contains(element))
                        temp[newlen++] = element;
                }
                if (newlen != len) {
                    setArray(Arrays.copyOf(temp, newlen));
                    return true;
                }
            }
            return false;
        } finally {
            lock.unlock();
        }
    }

十一、removeRange()方法

void removeRange(int fromIndex, int toIndex) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            //检查下标是否合法
            if (fromIndex < 0 || toIndex > len || toIndex < fromIndex)
                throw new IndexOutOfBoundsException();
            //计算新长度
            int newlen = len - (toIndex - fromIndex);
            //需要移动的元素个数
            int numMoved = len - toIndex;
            //没有元素需要移动
            if (numMoved == 0)
                setArray(Arrays.copyOf(elements, newlen));
            else {
                Object[] newElements = new Object[newlen];
                System.arraycopy(elements, 0, newElements, 0, fromIndex);
                System.arraycopy(elements, toIndex, newElements,
                                 fromIndex, numMoved);
                setArray(newElements);
            }
        } finally {
            lock.unlock();
        }
    }