CopyOnWriteArrayList核心源码阅读

Copy-On-Write，简称COW，是一种用于集合的并发访问的优化策略。改策略能够实现对CopyOnWrite集合容器进行写入操作（添加、修改、删除）时的线程安全，同时不影响并发进行的读取操作。

CopyOnWriteArrayList是线程安全的ArrayList，它的内部存储结构是Object[ ]数组。

CopyOnWriteArrayList核心源代码：

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    
    final transient ReentrantLock lock = new ReentrantLock();// 创建ReentrantLock锁对象

    private transient volatile Object[] array;// 

    // getArray()方法，返回原数组
    final Object[] getArray() {
        return array;
    }

    // 调用setArray()方法，将原数组引用指向新数组（替换原数组）
    final void setArray(Object[] a) {
        array = a;
    }

    
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }

    // 返回数组中下标为index的元素
    @SuppressWarnings("unchecked")
    private E get(Object[] a, int index) {
        return (E) a[index];
    }

    // 返回数组中下标为index的元素
    public E get(int index) {
        return get(getArray(), index);
    }

    // 将集合中下标为index的元素替换为element
    public E set(int index, E element) {
        final ReentrantLock lock = this.lock;
        lock.lock();// 加锁
        try {
            Object[] elements = getArray();// 获得原数组
            E oldValue = get(elements, index);// 获得原数组中下标为index的元素
            // 判断两个元素是否相等
            if (oldValue != element) {
                int len = elements.length;// 获得原数组长度
                Object[] newElements = Arrays.copyOf(elements, len);// 创建新数组，将原数组的元素复制到新数组中，新数组长度等于原数组
                newElements[index] = element;// 将新数组中下标为index的元素替换为element
                setArray(newElements);// 调用setArray()方法，将原数组引用指向新数组
            } else {
                setArray(elements);// 调用setArray()方法，将原数组引用指向新数组
            }
            return oldValue;// 返回原数组中下标为index的元素
        } finally {
            lock.unlock();// 释放锁
        }
    }

    // 向集合中添加元素
	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);// 复制创建新数组，新数组长度+1
            newElements[len] = e;// 将新元素添加到新数组中
            setArray(newElements);// 调用setArray()方法，将原数组引用指向新数组
            return true;
        } finally {
            lock.unlock();// 释放锁
        }
    }

    // 向集合中指定下标位置添加元素
    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;
            // numMoved等于0，将元素添加至新数组最后即可
            if (numMoved == 0)
                newElements = Arrays.copyOf(elements, len + 1);
            else {
                newElements = new Object[len + 1];// 新数组长度+1
                System.arraycopy(elements, 0, newElements, 0, index);// 将原数组下标是index之前的元素复制到新数组中 
                System.arraycopy(elements, index, newElements, index + 1,
                                 numMoved);// 将原数组下标是index包括之后的元素复制到新数组下标是index的之后
            }
            newElements[index] = element;// 将新元素添加到指定下标位置
            setArray(newElements);// 调用setArray()方法，将原数组引用指向新数组
        } finally {
            lock.unlock();// 释放锁
        }
    }

    // 删除集合中指定下标元素
    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);// 调用get(Object[] a, int index)方法获取原数组中要删除的元素
            int numMoved = len - index - 1;
            // numMoved等于0，说明需要删除的元素是原数组中的最后一个元素
            if (numMoved == 0)
                setArray(Arrays.copyOf(elements, len - 1));// 复制原数组中前len-1个元素到新数组中，新数组长度为len-1
            else {
                Object[] newElements = new Object[len - 1];// 创建新数组，新数组长度为len-1 
                System.arraycopy(elements, 0, newElements, 0, index);// 将原数组下标位置之前的元素复制到新数组
                System.arraycopy(elements, index + 1, newElements, index,// 将原数组下标位置之后的元素复制到新数组
                                 numMoved);
                setArray(newElements);// 调用setArray()方法，将原数组引用指向新数组
            }
            return oldValue;// 返回原数组中被删除的元素
        } finally {
            lock.unlock();// 释放锁
        }
    }

    //删除集合中一定范围内的元素
    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;
            // numMoved等于0，复制原数组中的前newlen个元素到新数组中
            if (numMoved == 0)
                setArray(Arrays.copyOf(elements, newlen));
            else {
                Object[] newElements = new Object[newlen];// 创建新数组
                System.arraycopy(elements, 0, newElements, 0, fromIndex);// 将原数组下标位置在fromIndex之前的元素复制到新数组中
                System.arraycopy(elements, toIndex, newElements,
                                 fromIndex, numMoved);// 将原数组下标位置在toIndex之后的元素复制到新数组中
                setArray(newElements);// 调用setArray()方法，将原数组引用指向新数组
            }
        } finally {
            lock.unlock();// 释放锁
        }
    }

    // 判断两个集合是否有交集，有返回true，没有返回false
    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) {
                int newlen = 0;
                Object[] temp = new Object[len];
                for (int i = 0; i < len; ++i) {
                    Object element = elements[i];
                    // 调用contains()方法，判断集合c中是否包含元素element，包含返回false，不包含返回true
                    if (!c.contains(element))
                        temp[newlen++] = element;
                }
                // newlen不等于len，两个集合有交集
                if (newlen != len) {
                    setArray(Arrays.copyOf(temp, newlen));// 调用setArray()方法，将原数组引用指向新数组
                    return true;
                }
            }
            return false;
        } finally {
            lock.unlock();// 释放锁
        }
    }

    // 清除集合中的元素
    public void clear() {
        final ReentrantLock lock = this.lock;
        lock.lock();// 加锁
        try {
            setArray(new Object[0]);// 创建一个长度为0的新数组，调用setArray()方法，将新数组引用指向原数组
        } finally {
            lock.unlock();// 释放锁
        }
    }

    // 将集合c合并至原集合尾部
    public boolean addAll(Collection<? extends E> c) {
        // 获得集合c的内部Object[]数组
        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;// 获得原数组长度
            // 判断原集合中是否为空
            if (len == 0 && cs.getClass() == Object[].class)
                setArray(cs);// 调用setArray()方法，将原数组引用指向新数组cs
            else {
                Object[] newElements = Arrays.copyOf(elements, len + cs.length);// 创建新数组，将原数组元素复制到新数组中，新数组长度为len + cs.length
                System.arraycopy(cs, 0, newElements, len, cs.length);// 将数组cs中的元素复制到新数组中
                setArray(newElements);// 调用setArray()方法，将原数组引用指向新数组
            }
            return true;
        } finally {
            lock.unlock();// 释放锁
        }
    }

    // 重写sort()方法
    public void sort(Comparator<? super E> c) {
        final ReentrantLock lock = this.lock;
        lock.lock();// 加锁
        try {
            Object[] elements = getArray();// 获得原数组
            Object[] newElements = Arrays.copyOf(elements, elements.length);// 创建新数组，将原数组元素复制到新数组中，新数组长度等于原数组
            @SuppressWarnings("unchecked") E[] es = (E[])newElements;
            Arrays.sort(es, c);// 调用sort()方法对新数组排序
            setArray(newElements);// 调用setArray()方法，将原数组引用指向新数组
        } finally {
            lock.unlock();// 释放锁
        }
    }

    // 重写equals()方法
    public boolean equals(Object o) {
        if (o == this)
            return true;
        if (!(o instanceof List))
            return false;

        List<?> list = (List<?>)(o);
        Iterator<?> it = list.iterator();
        Object[] elements = getArray();
        int len = elements.length;
        for (int i = 0; i < len; ++i)
            if (!it.hasNext() || !eq(elements[i], it.next()))
                return false;
        if (it.hasNext())
            return false;
        return true;
    }

    // 重写hashCode()方法
    public int hashCode() {
        int hashCode = 1;
        Object[] elements = getArray();
        int len = elements.length;
        for (int i = 0; i < len; ++i) {
            Object obj = elements[i];
            hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
        }
        return hashCode;
    }
}

 总结

CopyOnWrite是一种读写分离的容器，进行写入操作（有锁）时，不影响读取操作（无锁）。CopyOnWriteArrayList内部使用ReentrantLock锁来维护线程安全。当我们往CopyOnWriteArrayList进行写入操作时，会先根据内部的Object[ ]数组复制出一个新的数组，然后在新的数组中进行写入操作，最后将原数组的引用指向新数组，此时并发进行的读取操作是在原数组中进行的。CopyOnWriteArrayList只能有一个线程进行写入操作，允许多个线程并发进行读取操作。