欢迎访问欧博网址!

沧州信息港房产:多线程高并发编程(9) -- CopyOnWrite写入时复制

欧博网址2个月前10

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

阳光诚信在线平台

阳光诚信在线官网(原诚信在线官网)现已开放阳光在线手机版、阳光在线电脑客户端下载。阳光在线娱乐戏公平、公开、公正,用实力赢取信誉。

上一篇 下一篇

猜你喜欢

最新文章
热门文章
热评文章
随机文章
热门标签