Java并发包之 CopyOnWriteArrayList

你们在学习Java的过程当中，或者工做中，始终都绕不开集合。在单线程环境下，ArrayList就能够知足要求。多线程时，咱们能够使用CopyOnWriteArrayList来保证数据安全。下面咱们一块儿来看看CopyOnWriteArrayList类中的一些值得学习的方法。

说明：代码部分，均基于JDK1.8

1、添加元素

写时复制思想

CopyOnWrite, 简称COW，顾名思义，就是写入的时候将当前集合复制一份副本出来，新写入的值添加到副本集合里，再将原集合的引用指向新的副本集合。基于这个原理，就能够不加锁实现并发读，由于当前集合并不会添加元素，不会形成冲突。一样的原理还应用在MySQL中建立快照的过程。

/**
	  * 将指定的元素追加到此列表的末尾
	  *
	  * @param e element to be appended to this list
	  * @return {@code true} (as specified by {@link Collection#add})
	  */
	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();
        }
    }

2、删除元素

ArrayList 遍历过程当中删除的问题

你们在学习Java期间，必定都有过使用forEach遍历ArrayList时删除元素都会获得一个java.util.ConcurrentModificationException的错误。这是由于在ArrayList的remove()方法中，有一个参数modCount 专门用来记录修改的次数，每删除一次就modCount++。在forEach遍历集合时，首先会记录final int expectedModCount = modCount，如果遍历过程当中发现expectedModCount!=modCount，则会抛出错误。

下面来看看具体代码

/**
     * 删除元素
     */
    public E remove(int index) {
	// 检查下标是否越界
        rangeCheck(index);
	// 记录修改次数
        modCount++;
	// 待删除的元素
        E oldValue = elementData(index);
	// 待删除元素下标以后的数组长度
        int numMoved = size - index - 1;
        if (numMoved > 0)
	      // 删除元素
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

   /**
     * forEach 方法
     */
    @Override
    public void forEach(Consumer<? super E> action) {
        Objects.requireNonNull(action);
	// 记录modCount
        final int expectedModCount = modCount;
        @SuppressWarnings("unchecked")
        final E[] elementData = (E[]) this.elementData;
        final int size = this.size;
	// 遍历时判断modCount
        for (int i=0; modCount == expectedModCount && i < size; i++) {
            action.accept(elementData[i]);
        }
	// 不相同，抛出异常
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

因此使用ArrayList时，若是你有遍历删除某个元素的场景，咱们能够使用迭代器来删除。

CopyOnWriteArrayList 的删除

先来看看CopyOnWriteArrayList的remove()方法的源码，总体逻辑与ArrayList的remove()方法一直，有区别的是没有记录修改次数，由于每次删除都是从新获取的当前数组。而forEach()方法在遍历时也是获取的当前数组，所以在使用forEach遍历时删除元素不会抛出异常。

/**
     * 删除元素
     */
    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;
	      // 为0表明待删除元素就在数组的末尾
            if (numMoved == 0)
                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);
            }
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

   /**
     * 遍历方法
     */
    public void forEach(Consumer<? super E> action) {
        if (action == null) throw new NullPointerException();
		// 获取当前数组
        Object[] elements = getArray();
        int len = elements.length;
        for (int i = 0; i < len; ++i) {
            @SuppressWarnings("unchecked") E e = (E) elements[i];
            action.accept(e);
        }
    }

值得注意的是，CopyOnWriteArrayList的迭代器实现里的remove()方法会直接抛出异常，所以在使用迭代器遍历元素时，不能删除元素。

总结

使用场景

基于原理，不难分析出CopyOnWriteArrayList适用于读多写少的并发环境

须要注意的点

由于每次添加元素都须要复制一份副本，因此最好是使用批量添加，减小复制副本的次数

缺点

1、内存占用问题。 由于 CopyOnWrite 的写时复制机制，因此在进行写操做的时候，内存里会同时驻扎两个对象的内存，这一点会占用额外的内存空间。

2、数据一致性问题。 因为 CopyOnWrite 容器的修改是先修改副本，因此此次修改对于其余线程来讲，并非实时能看到的，只有在修改完以后才能体现出来。若是你但愿写入的的数据立刻能被其余线程看到，CopyOnWrite 容器是不适用的。