CopyOnWriteArrayList详解

    CopyOnWriteArrayList是ArrayList 的一个线程安全的变体，其中全部可变操做（add、set等等）都是经过对底层数组进行一次新的复制来实现的。

     这通常须要很大的开销，可是当遍历操做的数量大大超过可变操做的数量时，这种方法可能比其余替代方法更 有效。在不能或不想进行同步遍历，但又须要从并发线程中排除冲突时，它也颇有用。“快照”风格的迭代器方法在建立迭代器时使用了对数组状态的引用。此数组在迭代器的生存期内不会更改，所以不可能发生冲突，而且迭代器保证不会抛出ConcurrentModificationException。建立迭代器之后，迭代器就不会反映列表的添加、移除或者更改。在迭代器上进行的元素更改操做（remove、set和add）不受支持。这些方法将抛出UnsupportedOperationException。容许使用全部元素，包括null。

    内存一致性效果：当存在其余并发 collection 时，将对象放入CopyOnWriteArrayList以前的线程中的操做 happen-before 随后经过另外一线程从CopyOnWriteArrayList中访问或移除该元素的操做。 

   这种状况通常在多线程操做时，一个线程对list进行修改。一个线程对list进行fore时会出现java.util.ConcurrentModificationException错误。

   下面来看一个列子：两个线程一个线程fore一个线程修改list的值。

package com.lucky.concurrent.list;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CopyOnWriteArrayListDemo {
	/**
	 * 读线程
	 * @author wangjie
	 *
	 */
	private static class ReadTask implements Runnable {
		List<String> list;

		public ReadTask(List<String> list) {
			this.list = list;
		}

		public void run() {
			for (String str : list) {
				System.out.println(str);
			}
		}
	}
	/**
	 * 写线程
	 * @author wangjie
	 *
	 */
	private static class WriteTask implements Runnable {
		List<String> list;
		int index;

		public WriteTask(List<String> list, int index) {
			this.list = list;
			this.index = index;
		}

		public void run() {
			list.remove(index);
			list.add(index, "write_" + index);
		}
	}

	public void run() {
		final int NUM = 10;
		List<String> list = new ArrayList<String>();
		for (int i = 0; i < NUM; i++) {
			list.add("main_" + i);
		}
		ExecutorService executorService = Executors.newFixedThreadPool(NUM);
		for (int i = 0; i < NUM; i++) {
			executorService.execute(new ReadTask(list));
			executorService.execute(new WriteTask(list, i));
		}
		executorService.shutdown();
	}

	public static void main(String[] args) {
		new CopyOnWriteArrayListDemo().run();
	}
}

运行结果：

从结果中能够看出来。在多线程状况下报错。其缘由就是多线程操做结果：那这个种方案不行咱们就换个方案。用jdk自带的类CopyOnWriteArrayList来作容器。这个类和ArrayList最大的区别就是add(E) 的时候。容器会自动copy一份出来而后再尾部add(E)。看源码：

/**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return <tt>true</tt> (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
	final ReentrantLock lock = this.lock;
	lock.lock();
	try {
	    Object[] elements = getArray();
	    int len = elements.length;
	    Object[] newElements = Arrays.copyOf(elements, len + 1);
	    newElements[len] = e;
	    setArray(newElements);
	    return true;
	} finally {
	    lock.unlock();
	}
    }

用到了Arrays.copyOf 方法。这样致使每次操做的都不是同一个引用。也就不会出现java.util.ConcurrentModificationException错误。
换了种方案看代码：

//		List<String> list = new ArrayList<String>();
		CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();

也就把容器list换成了 CopyOnWriteArrayList，其余的没变。线程里面的list不用改。由于 CopyOnWriteArrayList实现的也是list<E> 接口。看结果：

其结果没报错。
CopyOnWriteArrayList add(E) 和remove(int index)都是对新的数组进行修改和新增。因此在多线程操做时不会出现java.util.ConcurrentModificationException错误。
因此最后得出结论：CopyOnWriteArrayList适合使用在读操做远远大于写操做的场景里，好比缓存。发生修改时候作copy，新老版本分离，保证读的高性能，适用于以读为主的状况。