一篇文章搞懂 CopyOnWriteArrayList

前言

本文隶属于专栏《100个问题搞定Java并发》，该专栏为笔者原创，引用请注明来源，不足和错误之处请在评论区帮忙指出，谢谢！

本专栏目录结构和参考文献请见100个问题搞定Java并发

正文

WHY

在很多应用场景中，读操作可能会远远大于写操作。

比如，有些系统级别的信息，往往只需要加载或者修改很少的次数，但是会被系统内所有模块频繁访问。

对于这种场景，我们最希望看到的就是读操作可以尽可能地快，而写即使慢一些也没有太大关系。

由于读操作根本不会修改原有的数据，因此对于每次读取都进行加锁其实是一种资源浪费。

我们应该允许多个线程同时访问 List 的内部数据，毕竟读取操作是安全的。

根据读写锁的思想，读锁和读锁之间确实也不冲突。

关于读写锁请参考我的博客——ReadWriteLock 是什么？怎么用？

但是，读操作会受到写操作的阻碍，当写发生时，读就必须等待，否则可能读到不一致的数据。

同理，当读操作正在进行时，程序也不能进行写入。

为了将读取的性能发挥到极致， JDK 中提供了 CopyOnWriteArrayList 类。

WHAT

对 CopyOnWriteArrayList 来说，读取是完全不用加锁的，并且更好的消息是:写入也不会阻塞读取操作。

只有写入和写入之间需要进行同步等待。

这样，读操作的性能就会大幅度提升。

它是怎么做的呢?

从这个类的名字我们可以看到，所谓 CopyOnWrite 就是在写入操作时，进行一次自我复制。

换句话说，当这个 List 需要修改时，我并不修改原有的内容(这对于保证当前在读线程的数据一致性非常重要)，而是对原有的数据进行一次复制，将修改的内容写入副本中。

写完之后，再用修改完的副本替换原来的数据，这样就可以保证写操作不会影响读了。

源码分析（JDK8）

读取

    /** The array, accessed only via getArray/setArray. */
    private transient volatile Object[] array;
    
    /**
     * Gets the array.  Non-private so as to also be accessible
     * from CopyOnWriteArraySet class.
     */
    final Object[] getArray() {
        return array;
    }

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

    /**
     * {@inheritDoc}
     *
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public E get(int index) {
        return get(getArray(), index);
    }

需要注意的是: 读取代码没有任何同步控制和锁操作，理由就是内部数组 array 不会发生修改，只会被另外一个 array 替换，因此可以保证数据安全。

和简单的读取相比，写入操作就有些麻烦了。

写入

    /** The lock protecting all mutators */
    final transient ReentrantLock lock = new ReentrantLock();

    /**
     * Appends the specified element to the end of this list.
     *
     * @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();
        }
    }
    
    /**
     * Sets the array.
     */
    final void setArray(Object[] a) {
        array = a;
    }

首先，写入操作使用锁，当然这个锁仅限于控制写-写的情况。

其重点在于 使用 System.arraycopy 代码进行了内部元素的完整复制。

因此，会生成一个新的数组 newElements 。

将新的元素加入 newElements ，然后使用新的数组替换老的数组，修改就完成了。

整个过程不会影响读取，并且修改完后，读取线程可以立即“察觉”到这个修改(因为 array 变量是 volatile 类型)。

关于 volatile 请参考我的这篇博客——volatile 的实现原理是什么？