CopyOnWrite寫入時複製

　　CopyOnWrite，即快照模式，寫入時複製就是不同執行緒訪問同一資源的時候，會獲取相同的指標指向這個資源，只有在寫操作，才會去複製一份新的資料，然後新的資料在被寫操作完後立馬被其他執行緒看到最新的資料變化，然後之前獲取的指標會指向新的資料，但在寫操作未結束時，其他執行緒仍然能訪問最初的資源。此做法主要的優點是如果沒有執行緒進行寫操作，就不會進行資料副本的複製，因此多個執行緒只是讀取操作時可以共享同一份資源。

　　下面以CopyOnWriteArrayList為例：

　　測試：

    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        System.out.println("主執行緒-0:"+list.toString());
        new Thread(()->{
            System.out.println("讀子執行緒-0:"+list.toString());
        }).start();
        new Thread(()->{
            list.add("d");
            System.out.println("寫子執行緒-0:"+list.toString());
        }).start();
        new Thread(()->{
            System.out.println("讀子執行緒-1:"+list.toString());
        }).start();
        list.add("e");
        new Thread(()->{
            System.out.println("讀子執行緒-2:"+list.toString());
        }).start();
        System.out.println("主執行緒-1:"+list.toString());
        new Thread(()->{
            list.add("f");
            System.out.println("寫子執行緒-1:"+list.toString());
        }).start();
        System.out.println("主執行緒-2:"+list.toString());
        new Thread(()->{
            System.out.println("讀子執行緒-3:"+list.toString());
        }).start();
    }
//=======結果========
主執行緒-0:[a, b, c]
讀子執行緒-0:[a, b, c]
寫子執行緒-0:[a, b, c, d]
讀子執行緒-1:[a, b, c, d, e]//主執行緒寫e立馬被讀子執行緒1發現
主執行緒-1:[a, b, c, d, e]//主執行緒寫e後輸出
讀子執行緒-2:[a, b, c, d, e]
主執行緒-2:[a, b, c, d, e]
寫子執行緒-1:[a, b, c, d, e, f]
讀子執行緒-3:[a, b, c, d, e, f]

 　　CopyOnWriteArrayList.add/set/remove/get原始碼探究

　　  add：

    private transient volatile Object[] array;//volatile確保陣列的可見性
    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);//重新拷貝一份新陣列，長度+1
            newElements[len] = e;//元素加入新陣列
            setArray(newElements);//陣列引用重新指向新陣列，即進行舊陣列的覆蓋
            return true;
        } finally {
            lock.unlock();//釋放鎖
        }
    }

　　set：

    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：

    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)//移除尾部資料
                setArray(Arrays.copyOf(elements, len - 1));//直接擷取陣列，把尾部去掉
            else {
                Object[] newElements = new Object[len - 1];//建立新陣列，長度-1
                System.arraycopy(elements, 0, newElements, 0, index);//複製指定位置前面的資料
                System.arraycopy(elements, index + 1, newElements, index,
                                 numMoved);//複製指定位置後面的資料
                setArray(newElements);//陣列引用重新指向
            }
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

 　　get：從中可以看到，沒有加鎖，直接返回指定位置的元素

    public E get(int index) {
        return get(getArray(), index);
    }
    private E get(Object[] a, int index) {
        return (E) a[index];
    }

 　　CopyOnWriteArrayList探討：

1. CopyOnWriteArrayList和Vector的比較：Vector每個方法都加了synchronized，相比CopyOnWriteArrayList只在寫操作加鎖效能要提升很多；
2. CopyOnWriteArrayList適合讀多寫少的併發場景，比如配置、白名單，黑名單，商品類目的訪問和更新場景、物流地址等變化非常少的資料；
3. CopyOnWriteArrayList存在記憶體問題，即每次的寫操作都要進行資源的複製、替換，如果資源物件佔用的記憶體過大，可能導致頻繁的Yong GC和Full GC，會造成程式的響應時間變長；
4. CopyOnWriteArrayList儘量使用批量新增操作addAll方法；
5. CopyOnWrite容器只能保證資料的最終一致性，不能保證資料的實時一致性。

　　CopyOnWriteArraySet

　　一個Set使用內部CopyOnWriteArrayList其所有操作。

public class CopyOnWriteArraySet<E> extends AbstractSet<E>
        implements java.io.Serializable {

    private final CopyOnWriteArrayList<E> al;

    public CopyOnWriteArraySet() {
        al = new CopyOnWriteArrayList<E>();
    }
    public boolean add(E e) {
        return al.addIfAbsent(e);
    }
}
public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    public boolean addIfAbsent(E e) {//如果元素已經存在，返回false，否則進行寫操作(CopyOnWrite)
        Object[] snapshot = getArray();
        return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false :
            addIfAbsent(e, snapshot);
    }
}