CopyOnWriteArrayList源码分析

CopyOnWriteArrayList是Copy-On-Write简称COW的一种实现。

CopyOnWriteArrayList是线程安全的，内部结构为Object[]数组，允许多个线程并发读取，但是只可以有一个县城写入。

特性：

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

 准备工作

implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
	//定义了一个可重入锁
    final transient ReentrantLock lock = new ReentrantLock();
	//一个私有的且安全的、可见的数组
    private transient volatile Object[] array;
	//得到数组的方法
    final Object[] getArray() {
        return array;
    }
	//得到数组的值
    final void setArray(Object[] a) {
        array = a;
    }

无参构造方法

//复制数组的方法
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }

有参构造方法 

 public CopyOnWriteArrayList(Collection<? extends E> c) {
		//原始数组
        Object[] elements;
		//判断传入的数组的方法和复制数组的方法是否相同
        if (c.getClass() == CopyOnWriteArrayList.class)
			//相同则直接将传入的数组存入原始数组中
            elements = ((CopyOnWriteArrayList<?>)c).getArray();
        else {
			//直接将当前集合c赋值给elements
            elements = c.toArray();
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
			//数组类型不是Object[]类型，对数组进行复制操作
            if (elements.getClass() != Object[].class)

                elements = Arrays.copyOf(elements, elements.length, Object[].class);
        }

        setArray(elements);
    }

修改指定下标的值 

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) {
		//调用ReentrantLock锁
        final ReentrantLock lock = this.lock;
		//加锁
        lock.lock();
        try {
			//得到原始数组的值
            Object[] elements = getArray();
			//计算原始数组的长度
            int len = elements.length;
			//通过copyOf方法将原始数组复制到新数组中并且把新数组的长度加一
            Object[] newElements = Arrays.copyOf(elements, len + 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 - 1;
			//如果等于0，则在数组的最后一位添加值
            if (numMoved == 0)
				//通过copyOf方法将原始数组复制到新数组中并且把新数组的长度加一
                newElements = Arrays.copyOf(elements, len + 1);
            else {
				//重新定义新数组的长度加一
                newElements = new Object[len + 1];
				//将原始数组直接复制进入新数组
                System.arraycopy(elements, 0, newElements, 0, index);
				//将原始数组的值从0到指定的index复制到新数组的index+1的长度
                System.arraycopy(elements, index, newElements, index + 1,
                                 numMoved);
            }
			//把新元素添加到新数组中
            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;
			//为0
            if (numMoved == 0)
				//则删除的是原始数组的最后一位，则只需将原始数组提前一位复制并且得到值
                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();
        }
    }

删除指定范围的元素 

//从开始下标删除至末尾下标
    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 - 1;
			//等于0则删除的是最后一位
            if (numMoved == 0)
				//直接得到对原始数组的复制但是只复制newlen长度
                setArray(Arrays.copyOf(elements, newlen));
            else {
				//定义新数组并且长度为原始数组删除指定段落之外的长度
                Object[] newElements = new Object[newlen];
				//复制原始数组的内容至新数组中并且复制开始指定下标的长度
                System.arraycopy(elements, 0, newElements, 0, fromIndex);
				//将原始数组的toIndex长度的值复制到新数组的fromIndex的位置开始并且复制剩余的长度
                System.arraycopy(elements, toIndex, newElements,
                                 fromIndex, numMoved);
				//将原始数组的引用指向新数组
                setArray(newElements);
            }
        } finally {
			//释放锁
            lock.unlock();
        }
    }

复制保持原来的整个数组 

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;
			//判断长度是否为0
            if (len != 0) {
                // temp array holds those elements we know we want to keep
				//给新的长度赋值为0
                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;
                }
				//如果长度不等于0
                if (newlen != len) {
					//直接复制数组
                    setArray(Arrays.copyOf(temp, newlen));
                    return true;
                }
            }
            return false;
        } finally {
            lock.unlock();
        }
    }

清空集合 

public void clear() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
			//将原数组的引用指向新数组并且长度为0 则清空
            setArray(new Object[0]);
        } finally {
            lock.unlock();
        }
    }

在指定位置批量添加元素 

 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
            if (cs.length == 0)
                return false;
			//计算长度减去下标后剩余的长度
            int numMoved = len - index;
			//定义新数组
            Object[] newElements;
			//等于0则添加到末尾
            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();
        }
    }