并发容器CopyOnWriteArrayList

时间  2019-11-15
标签 并发 容器 copyonwritearraylist 栏目 Java 繁體版
原文   原文链接

Copy-On-Write简称COW，是一种用于程序设计中的优化策略。其基本思路是，从一开始你们都在共享同一个内容，当某我的想要修改这个内容的时候，才会真正把内容Copy出去造成一个新的内容而后再改，这是一种延时懒惰策略。从JDK1.5开始Java并发包里提供了两个使用CopyOnWrite机制实现的并发容器,它们是CopyOnWriteArrayList和CopyOnWriteArraySet。CopyOnWrite容器很是有用，能够在很是多的并发场景中使用到。java

CopyOnWrite容器即写时复制的容器。通俗的理解是当咱们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，而后新的容器里添加元素，添加完元素以后，再将原容器的引用指向新的容器。这样作的好处是咱们能够对CopyOnWrite容器进行并发的读，而不须要加锁，由于当前容器不会添加任何元素。因此CopyOnWrite容器也是一种读写分离的思想，读和写不一样的容器。数组

CopyOnWriteArrayList至关于线程安全的ArrayList，经过增长写时复制语义来实现线程安全性。底层也是经过一个可变数组来实现的。可是和ArrayList不一样的时，它具备如下特性：安全

  1.  它最适合于具备如下特征的应用程序：List 大小一般保持很小，只读操做远多于可变操做，须要在遍历期间防止线程间的冲突
  2.  支持高效率并发且是线程安全的
  3.  由于一般须要复制整个基础数组，因此可变操做（add()、set() 和 remove() 等等）的开销很大
  4.  迭代器支持hasNext(), next()等不可变操做，但不支持可变 remove()等操做
  5.  使用迭代器进行遍历的速度很快，而且不会与其余线程发生冲突。在构造迭代器时，迭代器依赖于不变的数组快照

在使用CopyOnWriteArrayList以前，咱们先阅读其源码了解下它是如何实现的。如下代码是向CopyOnWriteArrayList中add方法的实现（向CopyOnWriteArrayList里添加元素），能够发如今添加的时候是须要加锁的，不然多线程写的时候会Copy出N个副本出来。数据结构

array: 保存了列表中的数据多线程

lock: 修改时加锁，用于保证线程安全并发

底层数据结构依然是数组，相比较于ArrayList而言，少了一个表示数组长度的size变量，获取列表长度是经过下面的方法函数

首先来看一下构造函数，以下所示：性能

    private volatile transient Object[] array;优化

    final Object[] getArray() {
        return array;
    }
    final void setArray(Object[] a) {
        array = a;
    }
    // -----开始构造函数----------------------------
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }
    public CopyOnWriteArrayList(Collection<? extends E> c) {
        Object[] elements = c.toArray();
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elements.getClass() != Object[].class)
            elements = Arrays.copyOf(elements, elements.length, Object[].class);
        setArray(elements);
    }
    // Creates a list holding a copy of the given array.
    public CopyOnWriteArrayList(E[] toCopyIn) {
        setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
    }网站

使用一个指向volatile类型的Object数组来保存容器元素。构造函数中都会根据参数值从新生成一个新的数组。

1.添加元素

 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);// 从新生成一个新的数组实例，并将原始数组的元素拷贝到新数组中
            newElements[len] = e;                                   // 添加新的元素到新数组的末尾
            setArray(newElements);                                  // 更新底层数组
            return true;
        } finally {
            lock.unlock();
        }
    }

读的时候不须要加锁，若是读的时候有多个线程正在向CopyOnWriteArrayList添加数据，读仍是会读到旧的数据，由于写的时候不会锁住旧的CopyOnWriteArrayList。

ArrayList新增元素时，可能致使数组扩容；CopyOnWriteArrayList在列表的修改时，采用数组拷贝，在新的数组上进行操做，从这点出发，应该不存在扩容的问题，由于每次修改都会致使数组的从新拷贝

有两点必须清楚：

 第一，在”添加操做“开始前，获取独占锁(lock)，若此时有须要线程要获取锁，则必须等待；在操做完毕后，释放独占锁(lock)，此时其它线程才能获取锁。经过独占锁，来防止多线程同时修改数据！

 第二，操做完毕时，会经过setArray()来更新volatile数组。对一个volatile变量的读，老是能看到（任意线程）对这个volatile变量最后的写入；这样，每次添加元素以后，其它线程都能看到新添加的元素。

2.获取元素：

public E get(int index) {
    return get(getArray(), index);
}

private E get(Object[] a, int index) {
    return (E) a[index];
}

将底层volatile数组指定索引处的元素返回便可。

3.删除元素：

以remove(int index)为例，来对“CopyOnWriteArrayList的删除操做”进行说明。下面是remove(int index)的代码：

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); // 获取volatile数组中指定索引处的元素值
        int numMoved = len - index - 1;
        if (numMoved == 0) // 若是被删除的是最后一个元素，则直接经过Arrays.copyOf()进行处理，而不须要新建数组
            setArray(Arrays.copyOf(elements, len - 1));
        else {
            Object[] newElements = new Object[len - 1];
            System.arraycopy(elements, 0, newElements, 0, index);    // 拷贝删除元素前半部分数据到新数组中
            System.arraycopy(elements, index + 1, newElements, index, numMoved);// 拷贝删除元素后半部分数据到新数组中
            setArray(newElements); // 更新volatile数组
        }
        return oldValue;
    } finally {
        lock.unlock();
    }
}

从删除的实现，可肯定如下几点：

  • 修改加锁，确保同一时刻只有一个线程对数组进行修改

  • 修改并非在原数组上进行的，而是建立一个新的数组，在新的数组上进行操做操做，而后将tables引用指向新的数组

  • 修改必然会涉及到数组内容的拷贝

4.遍历元素：

public Iterator<E> iterator() {
        return new COWIterator<E>(getArray(), 0);
    }
    public ListIterator<E> listIterator() {
        return new COWIterator<E>(getArray(), 0);
    }
    public ListIterator<E> listIterator(final int index) {
        Object[] elements = getArray();
        int len = elements.length;
        if (index<0 || index>len)
            throw new IndexOutOfBoundsException("Index: "+index);

        return new COWIterator<E>(elements, index);
    }

    private static class COWIterator<E> implements ListIterator<E> {
        private final Object[] snapshot; // 保存数组的快照，是一个不可变的对象
        private int cursor;

        private COWIterator(Object[] elements, int initialCursor) {
            cursor = initialCursor;
            snapshot = elements;
        }

        public boolean hasNext() {
            return cursor < snapshot.length;
        }

        public boolean hasPrevious() {
            return cursor > 0;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            if (! hasNext())
                throw new NoSuchElementException();
            return (E) snapshot[cursor++];
        }

        @SuppressWarnings("unchecked")
        public E previous() {
            if (! hasPrevious())
                throw new NoSuchElementException();
            return (E) snapshot[--cursor];
        }

        public int nextIndex() {
            return cursor;
        }

        public int previousIndex() {
            return cursor-1;
        }
        public void remove() {
            throw new UnsupportedOperationException();
        }
        public void set(E e) {
            throw new UnsupportedOperationException();
        }
        public void add(E e) {
            throw new UnsupportedOperationException();
        }
    }

如上容器的迭代器中会保存一个不可变的Object数组对象，那么在进行遍历这个对象时就不须要再进一步的同步。在每次修改时，都会建立并从新发布一个新的窗口副本，从而实现了可变性。如上迭代器代码中保留了一个指向volatile数组的引用，因为不会被修改，所以多个线程能够同时对它进行迭代，而不会彼此干扰或与修改容器的线程相互干扰。

与以前的ArrayList实现相比，CopyOnWriteArrayList返回迭代器不会抛出ConcurrentModificationException异常，即它不是fail-fast机制的！

 

JDK中并无提供CopyOnWriteMap，咱们能够参考CopyOnWriteArrayList来实现一个，基本代码以下：

import java.util.Collection;

import java.util.Map;

import java.util.Set;

public class CopyOnWriteMap<K, V> implements Map<K, V>, Cloneable {

    private volatile Map<K, V> internalMap;

    public CopyOnWriteMap() {

        internalMap = new HashMap<K, V>();

    }

    public V put(K key, V value) {

        synchronized (this) {

            Map<K, V> newMap = new HashMap<K, V>(internalMap);

            V val = newMap.put(key, value);

            internalMap = newMap;

            return val;

        }

    }

    public V get(Object key) {

        return internalMap.get(key);

    }

    public void putAll(Map<? extends K, ? extends V> newData) {

        synchronized (this) {

            Map<K, V> newMap = new HashMap<K, V>(internalMap);

            newMap.putAll(newData);

            internalMap = newMap;

        }

    }

}

CopyOnWrite的应用场景

CopyOnWrite并发容器用于读多写少的并发场景。好比白名单，黑名单，商品类目的访问和更新场景，假如咱们有一个搜索网站，用户在这个网站的搜索框中，输入关键字搜索内容，可是某些关键字不容许被搜索。这些不能被搜索的关键字会被放在一个黑名单当中，黑名单天天晚上更新一次。当用户搜索时，会检查当前关键字在不在黑名单当中，若是在，则提示不能搜索。实现代码以下：

package com.ifeve.book;

import java.util.Map;

import com.ifeve.book.forkjoin.CopyOnWriteMap;

/**

 * 黑名单服务

 *

 * @author fangtengfei

 *

 */

public class BlackListServiceImpl {

    private static CopyOnWriteMap<String, Boolean> blackListMap = new CopyOnWriteMap<String, Boolean>(

            1000);

    public static boolean isBlackList(String id) {

        return blackListMap.get(id) == null ? false : true;

    }

    public static void addBlackList(String id) {

        blackListMap.put(id, Boolean.TRUE);

    }

    /**

     * 批量添加黑名单

     *

     * @param ids

     */

    public static void addBlackList(Map<String,Boolean> ids) {

        blackListMap.putAll(ids);

    }

}

实现很简单，只要了解了CopyOnWrite机制，咱们能够实现各类CopyOnWrite容器，而且在不一样的应用场景中使用。

　代码很简单，可是使用CopyOnWriteMap须要注意两件事情：

　　1. 减小扩容开销。根据实际须要，初始化CopyOnWriteMap的大小，避免写时CopyOnWriteMap扩容的开销。

　　2. 使用批量添加。由于每次添加，容器每次都会进行复制，因此减小添加次数，能够减小容器的复制次数。如使用上面代码里的addBlackList方法。

CopyOnWrite的缺点

CopyOnWrite容器有不少优势，可是同时也存在两个问题，即内存占用问题和数据一致性问题。因此在开发的时候须要注意一下。

　　内存占用问题。由于CopyOnWrite的写时复制机制，因此在进行写操做的时候，内存里会同时驻扎两个对象的内存，旧的对象和新写入的对象（注意:在复制的时候只是复制容器里的引用，只是在写的时候会建立新对象添加到新容器里，而旧容器的对象还在使用，因此有两份对象内存）。若是这些对象占用的内存比较大，好比说200M左右，那么再写入100M数据进去，内存就会占用300M，那么这个时候颇有可能形成频繁的Yong GC和Full GC。以前咱们系统中使用了一个服务因为每晚使用CopyOnWrite机制更新大对象，形成了每晚15秒的Full GC，应用响应时间也随之变长。

　　针对内存占用问题，能够经过压缩容器中的元素的方法来减小大对象的内存消耗，好比，若是元素全是10进制的数字，能够考虑把它压缩成36进制或64进制。或者不使用CopyOnWrite容器，而使用其余的并发容器，如ConcurrentHashMap。

　　数据一致性问题。CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。因此若是你但愿写入的的数据，立刻能读到，请不要使用CopyOnWrite容器。

多记录一句：

Collections.synchronizedList & CopyOnWriteArrayList

       CopyOnWriteArrayList和Collections.synchronizedList是实现线程安全的列表的两种方式。两种实现方式分别针对不一样状况有不一样的性能表现，其中CopyOnWriteArrayList的写操做性能较差，而多线程的读操做性能较好。而Collections.synchronizedList的写操做性能比CopyOnWriteArrayList在多线程操做的状况下要好不少，而读操做由于是采用了synchronized关键字的方式，其读操做性能并不如CopyOnWriteArrayList。所以在不一样的应用场景下，应该选择不一样的多线程安全实现类。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程