CopyOnWriteArrayList核心代码阅读

1.概述:CopyOnWriteArrayList是java.util.concurrent并发包下的一个集合,它与ArrayList集合在方法行为上区别不大,最大的区别就是ArrayList集合是线程不安全的,在多线程并发的情况下，进行写操作,可能会造成数据丢失。而CopyOnWriteArrayList集合是线程安全的,使用ReentrantLock锁对写操作进行加锁,在同一时间内,只允许一个线程进行写操作。

2.部分核心代码阅读

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

    //真正存储数据的数组
    private transient volatile Object[] array;

    /**
     * Gets the array.  Non-private so as to also be accessible
     * from CopyOnWriteArraySet class.
     */
    //返回存储数据的数组
    final Object[] getArray() {
        return array;
    }

    /**
     * Sets the array.
     */
    //重新设置存储数据的数组
    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];
    }

    
    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;
                //将已修改的新数组设置为集合存储数据的array数组
                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;
            //将原来的数组以数组长度+1复制一份(因为要添加元素,长度比原来长度+1)
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            //设置最后一个元素为要添加的值
            newElements[len] = e;
            //将已经把元素添加进去的新数组设置为存储数据的array数组
            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;
            //如果下标大于len或小于0,抛出下标越界异常
            if (index > len || index < 0)
                throw new IndexOutOfBoundsException("Index: "+index+
            
                                                      ", Size: "+len);
            //声明一个新数组
            Object[] newElements;
            //计算需要移动的元素个数(需要将指定位置后面的元素往后移动)
            int numMoved = len - index;
            if (numMoved == 0)
                //需要移动的元素为0，说明添加元素至尾部,以原来长度+1的长度复制一份新数组
                newElements = Arrays.copyOf(elements, len + 1);
            else {
                //将新数组的长度定义为原来长度+1
                newElements = new Object[len + 1];
                //将指定位置的前面元素复制给新数组
                System.arraycopy(elements, 0, newElements, 0, index);
                //将指定位置的后面元素(包括指定位置的元素)复制给新数组,经过两次复制,新数组中指            
                //定位置的元素为空
                System.arraycopy(elements, index, newElements, index + 1,
                                 numMoved);
            }
            //将元素添加到指定位置
            newElements[index] = element;
            //将新数组设置为存储数据的array数组
            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)
                //需要移动的元素为0，说明要删除的元素为最后一个,只需要在复制新数组时,去掉最后                                
                //一个即可,并将新数组设置为存储数据的array数组
                setArray(Arrays.copyOf(elements, len - 1));
            else {
                //定义一个长度为原来长度-1的新数组
                Object[] newElements = new Object[len - 1];
                //将指定位置的前面元素复制给新数组
                System.arraycopy(elements, 0, newElements, 0, index);
                //跳过指定位置的元素,将后面的元素复制给新数组
                System.arraycopy(elements, index + 1, newElements, index,
                                 numMoved);
                //将新数组设置为存储数据的array数组
                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)
                //说明删除的元素为数组的尾部,直接将前面的元素复制一份,然后设置为存储数据的        
                //array数组
                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);
                //设置新数组为存储数据的array数组
                setArray(newElements);
            }
        } finally {
            lock.unlock();
        }
    }

    
    //删除Collection集合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];
                //遍历原来的数组,如果集合c中不包含元素,将元素添加到temp数组,newlen++
                for (int i = 0; i < len; ++i) {
                    Object element = elements[i];
                    if (!c.contains(element))
                        temp[newlen++] = element;
                }
                //如果新长度与原来的长度不相等
                if (newlen != len) {
                    //将temp数组中的元素复制一份设置为存储数据的array数组
                    setArray(Arrays.copyOf(temp, newlen));
                    return true;
                }
            }
            return false;
        } finally {
            lock.unlock();
        }
    }


    //清除集合   
    public void clear() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //直接定义一个空数组设置为存储数据的array数组
            setArray(new Object[0]);
        } finally {
            lock.unlock();
        }
    }

    //将集合c中的全部元素添加进来
    public boolean addAll(Collection<? extends E> c) {
        //获取集合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,集合c的数组cs为Object类型,直接将cs数组设置为存储数据的            
            //array数组
            if (len == 0 && cs.getClass() == Object[].class)
                setArray(cs);
            else {
                //将原来数组的元素以新长度复制一份,多出的部分为空
                Object[] newElements = Arrays.copyOf(elements, len + cs.length);
                //把多出的部分设置为集合c中的元素
                System.arraycopy(cs, 0, newElements, len, cs.length);
                //将新数组设置为存储数据的array数组
                setArray(newElements);
            }
            return true;
        } finally {
            lock.unlock();
        }
    }

    
    //排序
    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工具类对新数组进行排序
            Arrays.sort(es, c);
            //将排好序的新数组设置为存储数据的array数组
            setArray(newElements);
        } finally {
            lock.unlock();
        }
    }

    //比较值
    public boolean equals(Object o) {
        //如果两个对象为同一个对象,直接返回true
        if (o == this)
            return true;
        //如果o不是List集合,返回false
        if (!(o instanceof List))
            return false;
        //将o转换为集合
        List<?> list = (List<?>)(o);
        //获取迭代器
        Iterator<?> it = list.iterator();
        //获取当前CopyOnWriteArrayList集合存储数据的数组
        Object[] elements = getArray();
        int len = elements.length;
        //一个通过迭代器遍历,一个通过数组下标遍历,比较两个集合中的值,有一个值不同或长度不一致    
        //返回false
        for (int i = 0; i < len; ++i)
            if (!it.hasNext() || !eq(elements[i], it.next()))
                return false;
        //比较结束后,迭代器还存在下一个,说明集合o中的元素多,返回false
        if (it.hasNext())
            return false;
        return true;
    }

    //获取哈希值
    public int hashCode() {
        int hashCode = 1;
        Object[] elements = getArray();
        int len = elements.length;
        //遍历数组,计算hashCode,每次hashcode*31加上当前元素的hashCode
        for (int i = 0; i < len; ++i) {
            Object obj = elements[i];
            hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
        }
        return hashCode;
    }
}
 

通过上面代码的阅读, 可以看出CopyOnWriteArrayList集合在增，删，改的方法都加了锁,并且都会将原来的数组复制一份,在新的数组上修改好了之后才设置为集合存储数据的array数组,所以在对CopyOnWriteArrayList集合进行写操作的时候,保证了线程安全,但在每次写操作时,都要复制数组，影响性能。CopyOnWriteArrayList集合对读操作没做任何约束,可以多线程并发的读,提高读取效率,所以CopyOnWriteArrayList集合适用于读多写少的场景。但是在进行写操作的时候,可能也会进行读操作,所以CopyOnWriteArrayList集合在进行读操作的时候,可能会读到没完成写操作之前的旧数据。

3.CopyOnWriteArrayList集合和Vector集合的区别

Vector集合也是线程安全的集合,由于Vector集合使用的是synchronized关键字对方法进行加锁,所以不管是在进行写操作还是读操作的时候,都只能一个线程可以进行操作,性能非常低。而CopyOnWriteArrayList集合使用的是ReentrantLock锁,并且在进行写操作的同时，允许进行读操作,还可以多个线程并发进行读操作,读取效率高,性能高于Vector集合。

CopyOnWriteArrayList集合和Vector集合的区别

	CopyOnWriteArrayList	Vector集合
锁	ReentrantLock锁	synchronized锁
读操作	允许并发读,效率高	不允许并发读,效率低
写操作	不允许并发写	不允许并发写
性能	高	低