CopyOnWriteArrayList核心源码注解

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

基本思想：当一个线程向对一个集合容器进行操作时(增删改)，并不对原有集合容器进行操作，而是先将原有容器进行Copy，对新创建的集合容器进行操作，操作完成后将原容器的引用指向新集合容器，原有集合容器直接抛弃。

优势：实现了对CopyOnWriter容器写入操作的线程安全，且不影响同时进行的并发的读取操作；可理解为是一种读写分离思想。允许多个线程并发读取，但只能有一个线程写入。

源码理解:

public class CopyOnWriteArrayList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {

    //定义锁类型为ReentrantLock
    final transient ReentrantLock lock = new ReentrantLock();

    //CopyOnWriteArrayList内部维护的一个由迭代器所修饰的数组
    private transient volatile Object[] array;
    /**
     * Gets the array.  Non-private so as to also be accessible
     * from CopyOnWriteArraySet class.
     */
    //
    //获取数组array
    final Object[] getArray() {
        return array;
    }
    /**
     * Sets the array.
     */
    //改变数组指向，将arry指向数组a
    final void setArray(Object[] a) {
        array = a;
    }
    //无参构造函数，创建新数组
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }
    //获取指定下标的元素
    @SuppressWarnings("unchecked")
    private E get(Object[] a, int index) {
        return (E) a[index];
    }
    //对get方法重载
    public E get(int index) {
        return get(getArray(), index);
    }

    //改变指定下标位置元素
    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();
        }
    }


    //添加操作
    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);//将原容器指向新数组
            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;//计算插入位置
            //判断插入位置
            if (numMoved == 0)
                newElements = Arrays.copyOf(elements, len + 1);//插入尾部
            //插入位置在数组内部
            else {
                newElements = new Object[len + 1];//新建数组
                System.arraycopy(elements, 0, newElements, 0, index);//将插入位置的前部分copy至新数组
                System.arraycopy(elements, index, newElements, index + 1, numMoved);//将插入位置的后部分copy至新数组
            }
            newElements[index] = element;//指定位置放入新元素
            setArray(newElements);//将原容器指向新数组
        } 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);//获取指定位置的元素
            int numMoved = len - index - 1;//计算指定位置在当前数组的位置
            //判断指定位置
            if (numMoved == 0)
                setArray(Arrays.copyOf(elements, len - 1));//指定位置在尾部，则长度-1
            //指定位置在数组内部
            else {
                Object[] newElements = new Object[len - 1];//创建新数组，长度-1
                System.arraycopy(elements, 0, newElements, 0, index);//copy指定位置前的元素至新数组
                System.arraycopy(elements, index + 1, newElements, index,
                        numMoved);//copy指定位置后的元素至新数组
                setArray(newElements);//将原容器指向新数组
            }
            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;//保留的下半区长度
            if (numMoved == 0)//为0则只保留上半区，下半区全部删除
                setArray(Arrays.copyOf(elements, newlen));//将原容器指向新数组
            else {
                Object[] newElements = new Object[newlen];
                System.arraycopy(elements, 0, newElements, 0, fromIndex);//从原数组0位置开始向新数组0位置开始copy元素，长度为fromIndex
                System.arraycopy(elements, toIndex, newElements, fromIndex, numMoved);//从原数组toIndex位置开始向新数组fromIndex位置copy元素，长度为numMoved
                setArray(newElements);
            }
        } finally {
            lock.unlock();
        }
    }


    //从列表中删除指定集合中的所有元素
    public boolean removeAll(Collection<?> c) {
        if (c == null) throw new NullPointerException();//c为空抛出异常
        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;//新数组长度定义为0
                Object[] temp = new Object[len];//新建数组，长度为原数组长度
                //遍历集合
                for (int i = 0; i < len; ++i) {
                    Object element = elements[i];
                    //contains判断集合C中是否包含element,若包含返回true
                    if (!c.contains(element))
                        temp[newlen++] = element;//不包含则将当前element传入新数组temp中
                }
                //当新数组长度不等于原数组长度，则目标元素已删除
                if (newlen != len) {
                    setArray(Arrays.copyOf(temp, newlen));//将原容器指向新容器
                    return true;
                }
            }
            return false;//原数组长度为0则直接返回
        } finally {
            lock.unlock();
        }
    }



    //清空
    public void clear() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //返回一个新数组
            setArray(new Object[0]);
        } finally {
            lock.unlock();
        }
    }

    //添加指定列表至当前列表
    public boolean addAll(Collection<? extends E> c) {
        Object[] cs = (c.getClass() == CopyOnWriteArrayList.class) ? ((CopyOnWriteArrayList<?>)c).getArray() : c.toArray();//判断c与CopyOnWriteArrayList是否为同一类型
        // 是则将c转换为CopyOnWriteArrayList<?>类型，并交给cs
        // 不是则将c装换为数组，交给cs
        //判断cs长度
        if (cs.length == 0)
            return false;//为0则退出
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();//获取内部数组
            int len = elements.length;//获取内部数组长度
            //若内部数组长度为0且cs数组类型为Object
            if (len == 0 && cs.getClass() == Object[].class)
                setArray(cs);//将原容器指向cs
            else {
                Object[] newElements = Arrays.copyOf(elements, len + cs.length);//新建数组，并将原数组copy至新数组，新数组长度为原数组长度+新数组长度
                System.arraycopy(cs, 0, newElements, len, cs.length);//将cs数组从下标0开始copy至新数组，从下标len开始，长度为cs的长度
                setArray(newElements);//将原容器指向新数组
            }
            return true;
        } finally {
            lock.unlock();
        }
    }

    //使用Comparator方法(自定义比较)对列表排序
    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);//copy原数组为新数组
            @SuppressWarnings("unchecked") E[] es = (E[])newElements;//将新数组放入es
            Arrays.sort(es, c);//对es按照规则c进行排序
            setArray(newElements);//将原容器指向新数组
        } finally {
            lock.unlock();
        }
    }


    //判断是否有写入操作
    public boolean equals(Object o) {
        //地址相同
        if (o == this)
            return true;
        //判断o的类型是否为list
        if (!(o instanceof List))//o不为list
            return false;

        List<?> list = (List<?>)(o);//将o转化为List对象
        Iterator<?> it = list.iterator();//获取迭代器
        Object[] elements = getArray();//获得内部数组
        int len = elements.length;//获取数组长度
        for (int i = 0; i < len; ++i)
            //判断是否输入数据或判断elements[i], it.next()是否相同
            if (!it.hasNext() || !eq(elements[i], it.next()))//未输入数据或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());//计算hashcode值
        }
        return hashCode;//返回结果
    }
}

特性：

1.在保证并发读取的前提下，确保了写入时的线程安全
2.由于每次写入操作时，进行了Copy复制原数组，所以无需扩容
3.适合读多写少的应用场景。由于add()、set() 、 remove()等修改操作需要复制整个数组，所以会有内存开销大的问题
4.CopyOnWriteArrayList由于只在写入时加锁，所以只能保证数据的最终一致性，不能保证数据的实时一致性

向上攀爬的痛苦，终会在登顶时烟消云散

——ZQY