CopyOnWriteArrayList 源码分析

CopyOnWriteArrayList 源码分析

CopyOnWriteArrayList 位于 java.util.concurrent 包下,是一个线程安全的可变数组。内部采用写时复制策略，也就是增删改时加锁复制；读取数据时不加锁。

类图

添加元素

类中添加元素的方法很多 add(E e), add(int index, E element) 等，这里以 add(E e)进行分析。

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

主要流程就是 加锁，复制新数组，添加元素到新数组，替换旧数组。由于读取是不加锁的，所以在 替换旧数组前，所有的读取都是基于 旧数组的。

移除元素

同样的这里以 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);
          	// 计算需要移除的元素的上一个元素的下标，用于复制
            int numMoved = len - index - 1;
          	// 移除元素位于数组末尾
            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();
        }
    }

主要流程就是：加锁，复制，替换。 因为读取不加锁，所以在 remove操作步骤中的 替换 执行完成前，所有的读取都是基于 旧数组的。对于多线程来说，线程1 读取，线程2 删除并且已经执行完了 复制 操作，但由于还未执行 替换 操作，那么线程1仍然可以读取到被删除的元素，只有在线程2完成了替换之后，线程1才无法读取删除的元素。这就是写时复制策略的弱一致性问题。

迭代器

CopyOnWriteArrayList 中的迭代器使用的是其内部类 COWIterator。

static final class COWIterator<E> implements ListIterator<E> {
        /** Snapshot of the array */
        private final Object[] snapshot;
        /** Index of element to be returned by subsequent call to next.  */
        private int cursor;

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

构造方法是需要传入一个数组，和初始游标位置。这里与 ArrayList 的迭代器不同的是，ArrayList 遍历迭代器使用的是就是集合中存储元素的数组，而这里使用的是传入的数组。

在 获取迭代器之后，如果没有进行增删改(修改不一定会产生复制)，则集合中与迭代器中持有的是同一个数组的引用；否则，持有的是两个不同的数组，也就是说其他线程对于集合的修改对于迭代器是不可见的，这样就有了 迭代器的弱一致性问题。如果为了保证迭代器中的数据的实时性，需要保证在获取迭代器之后，不会在产生数组的复制操作。另外，迭代器中的增删改方法实现是不可用的，也是因为这个问题。

使用场景

CopyOnWriteArrayList 适用于多线程 读多写少 的场景。如果写入操作多，建议使用 SynchronzedList线程安全数组。因为 CopyOnWriteArrayList 写操作的不单单需要加锁，更需要数组的复制，那就意味着，在新增操作时，堆中是存在两个数组的，如果是数组较大，且写入操作多，是有可能会造成频繁 GC的。这里给出测试数据

写操作

多线程分别向 CopyOnWriteArrayList 和 SynchronizedList 写入 50000 数据，对比速度

 public static void add(){
        System.out.println("Synchronized: 添加元素");
        long synchronizedListAddStartTime = System.currentTimeMillis();
        List synchronizedList = Collections.synchronizedList(new ArrayList<>());
        IntStream.range(1,200000).parallel().forEach(synchronizedList::add);
        System.out.println("Synchronized: 添加元素耗时(ms)----" + (System.currentTimeMillis() - synchronizedListAddStartTime));
        System.out.println("CopyOnWriteArrayList: 添加元素");
        long copyOnWriteArrayListAddStartTime = System.currentTimeMillis();
        CopyOnWriteArrayList copyOnWriteArrayList = new CopyOnWriteArrayList();
        IntStream.range(1,200000).parallel().forEach(copyOnWriteArrayList::add);
        System.out.println("CopyOnWriteArrayList: 添加元素耗时(ms)----" + (System.currentTimeMillis() - copyOnWriteArrayListAddStartTime));
    }
// 执行结果
Synchronized: 添加元素
Synchronized: 添加元素耗时(ms)----97
CopyOnWriteArrayList: 添加元素
CopyOnWriteArrayList: 添加元素耗时(ms)----1878