CopyOnWriteArrayList源码分析

        CopyOnWriteArrayList是java.util.concurrent包下的一个并发集合，实现自List接口。底层使用Object[]数组实现，使用ReentrantLock加锁实现线程安全，相当于一个线程安全的ArrayList集合，它允许多个线程并发读取，但只允许一个线程写入，因此它一般用于少写多读的场景。

        CopyOnWriteArrayList采用了一种集合并发访问的优化策略，Copy-On-Write，简称COW，是一种读写分离的思想。当向集合容器中，写入元素时，并不会直接写入，而是将当前集合容器复制，复制一个新的集合容器，对这个新的集合容器进行写入操作，写入完成之后再将原容器的引用指向它。使用这种思想的优点就是：一个线程写的同时，允许多个线程读取。缺点是：在执行写操作过程中，进行读取读到的数据仍然是之前的数据，不能实时的读取新数据。

        接下来我们看看CopyOnWriteArrayList的源码

构造方法

        无参构造方法中初始化了一个容量为0的Object数组，有参构造方法传入一个集合，通过判断集合的Class对象，如果是CopyOnWriteArrayList.class则会获取传入集合中的Object数组存入新集合中，不是则先转换成数组再将元素复制到一个Object[]数组中。

源码如下：

    //创建ReentrantLock锁对象
    final transient ReentrantLock lock = new ReentrantLock();
    
    //volatile:保持可见性和有序性
    private transient volatile Object[] array;
    
    //获取当前数组
    final Object[] getArray() {
        return array;
    }
    
    //数组引用重新指向
    final void setArray(Object[] a) {
        array = a;
    }

    //构造方法
    public CopyOnWriteArrayList() {
    	//初始化数组容量为0;
        setArray(new Object[0]);
    }


    public CopyOnWriteArrayList(Collection<? extends E> c) {
        Object[] elements;
        //判断集合的class对象是否为CopyOnWriteArrayList
        if (c.getClass() == CopyOnWriteArrayList.class)
			//向上转型
			//得到当前集合对象中的Object[] array数组
            elements = ((CopyOnWriteArrayList<?>)c).getArray();
        else {
            elements = c.toArray();
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            //判断数组不是Object类型的数组
            if (elements.getClass() != Object[].class)
            	//将数组转换成Object类型数组
                elements = Arrays.copyOf(elements, elements.length, Object[].class);
        }
        //数组引用重新指向
        setArray(elements);
    }

set(int index, E element)方法

        对指定下标元素值进行修改，属于写入操作，修改过程中加锁，保证线程安全。先将集合中原数组复制一份，再修改复制的新数组中指定下标的元素值，最后原数组引用指向新数组。

    public E set(int index, E element) {
    	//获取锁
        final ReentrantLock lock = this.lock;
        //加锁
        lock.lock();
        try {
        	//获取当前类CopyOnWriteArrayList对象中数组(新引用指向它)
            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();
        }
    }

  

add(E e)方法：添加元素至集合尾部

    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            //复制新数组，长度+1
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            //将元素e添加至数组
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

add(int index, E element)方法：添加元素至指定下标位置

    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)
            	//复制数组并容量+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();
        }
    }

addAll(int index, Collection<? extends E> c)方法：添加集合至指定下标

    public boolean addAll(int index, Collection<? extends E> c) {
    	//装换成数组
        Object[] cs = c.toArray();
        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);
            //如果添加的数组长度为0,返回false
            if (cs.length == 0)
                return false;
            int numMoved = len - index;
            Object[] newElements;
            //判断是否插入集合尾部
            if (numMoved == 0)
            	//复制新数组长度=插入数组长度+原数组长度
                newElements = Arrays.copyOf(elements, len + cs.length);
            else {
            	//不是尾部
            	//创建新数组
                newElements = new Object[len + cs.length];
                //复制插入位置之前元素至新数组
                System.arraycopy(elements, 0, newElements, 0, index);
              //复制插入位置之后元素至新数组
                System.arraycopy(elements, index,
                                 newElements, index + cs.length,
                                 numMoved);
            }
            //复制插入数组元素至新数组
            System.arraycopy(cs, 0, newElements, index, cs.length);
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }
}

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;
          //判断添加位置是否为尾部
            if (numMoved == 0)
            	//复制len - 1个元素至新数组
                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();
        }
    }

removeRange(int fromIndex, int toIndex)方法：删除下标范围为fromIndex到toIndex的元素

    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)
            	//复制elements中newlen个元素至新数组
                setArray(Arrays.copyOf(elements, newlen));
            else {
            	//创建新数组
                Object[] newElements = new Object[newlen];
                //复制开fromIndex下标之前的元素
                System.arraycopy(elements, 0, newElements, 0, fromIndex);
              //复制toIndex下标之后的元素
                System.arraycopy(elements, toIndex, newElements,
                                 fromIndex, numMoved);
                setArray(newElements);
            }
        } finally {
            lock.unlock();
        }
    }

retainAll(Collection<?> c)方法：只在当前集合保留传入集合中的元素，其余的删除

    public boolean retainAll(Collection<?> c) {
    	//集合为null抛出异常
        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];
                    //判断集合c中是否包含elements中的元素
                    if (c.contains(element))
                    	//包含则将元素存入中间数组
                        temp[newlen++] = element;
                }
                //中间数组下标+1之后不等于elements数组长度
                if (newlen != len) {
                	//使用newlen作为新数组长度复制
                    setArray(Arrays.copyOf(temp, newlen));
                    return true;
                }
            }
            return false;
        } finally {
            lock.unlock();
        }
    }

clear()方法：清空集合

    public void clear() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
        	//清空数组(重新创建新数组并引用指向它)
            setArray(new Object[0]);
        } finally {
            lock.unlock();
        }
    }