CopyOnWriteArrayList核心源码阅读

一、什么是CopyOnWriteArrayList？

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

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

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

 二、具体内容

1、set()方法  

        修改指定下标元素时，会将当前数组Copy复制至新数组，将要修改的新元素替换原数据至数组中，最后替换原数组。在这个过程中，使用ReetantLock加锁，对线程进行保护，保护线程安全避免多个线程复制数组。

	// 用来给指定下标设置值，同时返回旧值，是一个写入操作，需要竞争到锁才能使用
	public E set(int index, E element) {
		final ReentrantLock lock = this.lock;
		lock.lock();// 加锁
		try {
			// 获取当前存储元素的数组
			Object[] elements = getArray();
			// 获取当前下标对应的旧元素
			E oldValue = get(elements, index);
			/*
			 * 判断：如果旧元素不等于新元素： 拷贝一个一样的数组，替换下标元素，然后写入array
			 */
			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
				// 即时元素没有变化，也要写入array
				setArray(elements);
			}
			// 返回旧的元素
			return oldValue;
		} finally {
			// 释放锁
			lock.unlock();
		}
	}

2、 Add()方法：

        添加新元素至集合时，会将当前数组Copy复制新数组，并将新元素添加至新数组，最后替换原数组。执行过程中，使用ReentrantLock加锁，保证线程安全，避免多个线程复制数组。（重载的add()方法和下述代码实现基本相同）。

// 通过指定下标添加元素，需要竞争锁
	public void add(int index, E element) {
		final ReentrantLock lock = this.lock;
		lock.lock();
		try {
			// 获取原数组
			Object[] elements = getArray();
			int len = elements.length;
			// 判断index是否合法
			if (index > len || index < 0)
				throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + len);
			// 新数组
			Object[] newElements;
			// 得到该下标距离末尾的长度
			int numMoved = len - index;
			if (numMoved == 0) // 如果等于0，意味着要添加在数组的末尾
				// 将当前数组长度加一复制到一个新数组中，前面的元素与本来的数组相同
				newElements = Arrays.copyOf(elements, len + 1);
			else {
				// 如果numMoved不为0，那么将新数组的长度设置为当前数组长度加一
				newElements = new Object[len + 1];
				// 拷贝旧数组从下标0到index-1的元素到新数组中
				System.arraycopy(elements, 0, newElements, 0, index);
				// 拷贝旧数组的其他元素到新数组下标为index+1到末尾，空出index的位置
				System.arraycopy(elements, index, newElements, index + 1, numMoved);
			}
			// 将新元素加入新数组中
			newElements[index] = element;
			// 写入array，覆盖原数组
			setArray(newElements);
		} finally {
			lock.unlock();
		}
	}

 3、Remove()方法：

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

// 通过指定下标删除集合元素 需要竞争锁
	public E remove(int index) {
		final ReentrantLock lock = this.lock;
		lock.lock();
		try {
			// 获取原数组
			Object[] elements = getArray();
			int len = elements.length;
			// 通过get方法获取指定下标对应的旧元素
			E oldValue = get(elements, index);
			// 计算该下标距离数组末尾的长度
			int numMoved = len - index - 1;
			if (numMoved == 0)
				// numMoved为0的时候，意味着需要删除的元素就是最后一个元素
				// 将当前数组长度减一直接写入原数组array，覆盖
				setArray(Arrays.copyOf(elements, len - 1));
			else {
				// numMoved不为0的时候，创建一个长度减一的新数组
				Object[] newElements = new Object[len - 1];
				// 拷贝原数组从下标0到index-1的元素到新数组
				System.arraycopy(elements, 0, newElements, 0, index);
				// 然后将原数组从index+1到结束复制到新数组的index下标位置，将原数组的index下标移除
				System.arraycopy(elements, index + 1, newElements, index, numMoved);
				// 然后覆盖原数组array
				setArray(newElements);
			}
			// 同时返回需要移除的元素
			return oldValue;
		} finally {
			lock.unlock();
		}
	}

 4、Get()方法：

        根据下标访问数组的元素，这个方法没有加锁，允许多线程并发。但如果在读取的同时有新的元素添加进数组，那么读取到的仍然是旧的数组内容。

// 私有的get方法，用来返回当前数组a下标为index的元素
	@SuppressWarnings("unchecked")
	private E get(Object[] a, int index) {
		return (E) a[index];
	}
 
	// 通过指定的下标获取指定的元素，调用get(Object[] a,int index)方法返回元素
	public E get(int index) {
		return get(getArray(), index);
}

 

总结CopyOnWriteArrayList的特性：

1、在保证并发读取的前提下，确保了写入时的线程安全；

2、由于每次写入操作时，进行了Copy复制原数组，所以无序扩容；

3、适合读少写多的应用场景。由于add()、set()、remove()等修改操作需要复制整个数组，所以会有内存开销大的问题；

4、CopyOnWriteArrayList由于只在写入的适合加锁，所以只能保证数据的最终一致性，不能保证数据的实时一致性。