前言

本文隶属于专栏《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 的实现原理是什么?

上一篇 下一篇