多线程高并发编程(9) -- CopyOnWrite写入时复制

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