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

  CopyOnWrite写入时复制

  CopyOnWrite,即快照模式,写入时复制就是不同线程访问同一资源的时候,会获取相同的指针指向这个资源,只有在写操作,才会去复制一份新的数据,然后新的数据在被写操作完后立马被其他线程看到最新的数据变化,然后之前获取的指针会指向新的数据,但在写操作未结束时,其他线程仍然能访问最初的资源。此做法主要的优点是如果没有线程进行写操作,就不会进行数据副本的复制,因此多个线程只是读取操作时可以共享同一份资源。

  下面以CopyOnWriteArrayList为例:

多线程高并发编程(9) -- CopyOnWrite写入时复制_第1张图片

  测试:

    public static void main(String[] args) {
        CopyOnWriteArrayList 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 extends AbstractSet
        implements java.io.Serializable {

    private final CopyOnWriteArrayList al;

    public CopyOnWriteArraySet() {
        al = new CopyOnWriteArrayList();
    }
    public boolean add(E e) {
        return al.addIfAbsent(e);
    }
}
public class CopyOnWriteArrayList
    implements List, 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);
    }
}

你可能感兴趣的:(多线程高并发编程(9) -- CopyOnWrite写入时复制)