CopyOnWriteArrayList源码分析

   前言

        CopyOnWriteArrayList是一个线程安全的ArrayList,他的内部存储架构采用Object[ ]数组,线程安全使用ReentrantLock实现他与ArrayList的最大区别就是,对我们在这个集合容器中对元素进行改动操作(删除,添加,修改)时会首先复制出一个新的集合容器,然后在新的集合容器中写入改动后的数组元素,最后将原容器的引用指向新容器

        因此,CopyOnWriteArrayList是一个写入操作时线程安全的集合,且允许进行并发读的操作,实现读写分离的思想

        接下来,我们查看CopyOnWriteArrayList底层关于写入的源码:

set()方法:

        修改指定下标元素

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

  add()方法

        添加新元素至末尾

 public boolean add(E e) {
	  //加锁
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
		//获取数组长度
            int len = elements.length;
		//复制原数组,长度为len+1
            Object[] newElements = Arrays.copyOf(elements, len + 1);
		//将要新元素添加至末尾
            newElements[len] = e;
		//更新数组
            setArray(newElements);
		//添加成功，返回true
            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)
		   //复制传入数组，长度为len+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()方法：将新数组赋值给定义数组
            setArray(newElements);
        } 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 {
		       //创建一个新数组，长度为len-1
                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)

        删除区间范围数据

    //删除区间范围数据
    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();
        }
    }

 retainAll(Collection<?> c)

        修改当前集合为传入集合与当前集合的交集,如果集合内容改变返回true,否则返回false;

    public boolean retainAll(Collection<?> c) {
    	  //如果传入集合为空，抛出异常NullPointerException
        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));
			//返回true
                    return true;
                }
            }
		//返回false
            return false;
        } finally {
		//释放锁
            lock.unlock();
        }
    }

clear()

        清空集合 

//清除
    public void clear() {
	  //加锁
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
		//清空数组
            setArray(new Object[0]);
        } 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)
			//复制数组,长度为len+cs.length
                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()方法
            setArray(newElements);
		//返回true
            return true;
        } finally {
		//释放锁
            lock.unlock();
        }
    }