多線程高並發編程(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);
    }
}