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

運行結果：

java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:859)
    at java.util.ArrayList$Itr.next(ArrayList.java:831)
    at com.java.thread.CopyOnWriteArrayListDemo$ReadTask.run(CopyOnWriteArrayListDemo.java:22)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    at java.lang.Thread.run(Thread.java:745)

　　從結果中可以看出來。在多線程情況下報錯。其原因就是多線程操作結果：那這個種方案不行我們就換個方案。用jdk自帶的類CopyOnWriteArrayList來做容器。這個類和ArrayList最大的區別就是add(E) 的時候。容器會自動copy一份出來然後再尾部add(E)。看源碼：
　　

5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

/**
    * 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 接口。就不會報異常了

總結：
　　CopyOnWriteArrayList add(E) 和remove(int index)都是對新的數組進行修改和新增。所以在多線程操作時不會出現java.util.ConcurrentModificationException錯誤。
所以最後得出結論：CopyOnWriteArrayList適合使用在讀操作遠遠大於寫操作的場景裏，比如緩存。發生修改時候做copy，新老版本分離，保證讀的高性能，適用於以讀爲主的情況。