多線程高併發編程(9) -- CopyOnWrite寫入時複製

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