CopyOnWriteArrayList源码分析

简介

        CopyOnWrite简称COW，是一种用于集合的并发访问的优化策略。当我们往集合容器中写入元素时（添加、修改、删除），并不会直接在集合容器中写入，而是先将当前集合容器进行Copy，复制出一个新的容器，然后新的容器写入元素，写入操作完成之后，再将原容器的引用指向新的容器。

       实现对CopyOnWrite集合容器写入操作时的线程安全，但同时并不影响进行并发的读取操作。所以CopyOnWrite容器也是一种读写分离的思想。从JDK1.5开始，Java提供了两个使用CopyOnWrite机制实现的实现的并发集合容器，它们是CopyOnArrayList和CopyOnWriteArraySet。

        CopyOnWriteArrayList相当于线程安全的ArrayList，内部存储结构采用Object[ ]数组，线程安全使用ReentrantLock实现，允许多个线程并发读取，但只能有一个线程写入。

成员属性

    // 创建一个可重入锁（transient修饰的成员属性变量不被序列化）
    final transient ReentrantLock lock = new ReentrantLock();
	// 定义一个线程安全的数组
    private transient volatile Object[] array;

主要方法

add( )方法：

        添加新元素至集合时，会将当前数组Copy复制新数组，并将新元素添加至新数组，最后替换原数组。与RenntrantLock配合，将add元素和旧数组一并复制到一个新数组。

1. 添加新元素至末尾位置

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);
			// 将元素放至最后一位
            newElements[len] = e;
			// 将操作后的新数组设置回去
            setArray(newElements);
            return true;
        } finally {
			// 释放锁
            lock.unlock();
        }
    }

set(int index, E element)方法

        修改指定下标的元素

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

remove( )方法：

        删除指定下标的元素，根据指定下标元素，从原数组中，Copy复制其他元素至新数组，最后替换原数组。

1. 删除指定下标元素

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)
				// 直接拷贝一份长度-1的数组新数组设置回去，最后一位就自动移除了
                setArray(Arrays.copyOf(elements, len - 1));
            else {
				// 否则，创建一个长度-1的新数组
                Object[] newElements = new Object[len - 1];
				// 将index之前的数组拷贝到新数组中
                System.arraycopy(elements, 0, newElements, 0, index);
				// 将index后的元素拷贝到新数组中
                System.arraycopy(elements, index + 1, newElements, index,
                                 numMoved);
				// 将操作完的新数组设置回去
                setArray(newElements);
            }
            return oldValue;
        } finally {
			// 释放锁
            lock.unlock();
        }
    }

2. 删除指定区间的元素

public 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 {
				// 创建一个长度位newlen的新数组
                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();
        }
    }

get( )方法：

        根据指定下标，到原数组中读取元素。

public E get(int index){
    // 根据指定下标，从数组中读取元素
    return get(getArray(), index);
}

CopyOnWriteArrayList具有以下特性：

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