Java8 - CopyOnWriteArrayList源码

一、概述

先来看看源码中的这一段注释，我们先尝试从中提取一些信息：

A thread-safe variant of java.util.ArrayList in which all mutative operations add, set, and so on are implemented by making a fresh copy of the underlying array.

从这段注释中，大致可以了解到 CopyOnWriteArrayList 是一个线程安全的数组容器，底层实现是基于数组的，它在对容器进行写操作的时候，是通过拷贝一个数组的副本来实现的。

读到这里，我们知道了 CopyOnWriteArrayList 是一个写时复制的容器，采用了读写分离的思想。通俗点来讲，在对容器进行写操作时，不直接修改当前容器，而是先对当前容器进行拷贝得到一个副本，然后对副本进行写操作，最后再将原容器的引用指向拷贝出来的副本。这样做的好处就是可以对容器进行并发读而不用进行加锁。

二、属性

接下来看一下 CopyOnWriteArrayList 中的属性：

//用于在对数组产生写操作的方法加锁
final transient ReentrantLock lock = new ReentrantLock();

//底层的存储结构
private transient volatile Object[] array;

CopyOnWriteArrayList 的主要属性就只有这两个，array 是 CopyOnWriteArrayList 底层的存储结构，采用的是一个 Object 数组；而lock 是用于对array执行写操作时进行加锁，保证同一时间里只有一个线程能对 array 进行写操作。下面，我们来看看他它的主要方法。

三、方法

1、构造函数

CopyOnWriteArrayList 有三个构造方法，默认的构造方法是为 array 数组进行初始化。如果我们一开始就有数据需要添加到容器里，我们可以通过第二或第三个构造方法来进行初始化，千万不要用默认的构造方法创建一个空的容器，然后再一个个添加到里面，这样做效率极差，具体原因请继续往下看。

public CopyOnWriteArrayList() {
    setArray(new Object[0]);
}


public CopyOnWriteArrayList(Collection<? extends E> c) {
    Object[] elements;
    if (c.getClass() == CopyOnWriteArrayList.class)
        elements = ((CopyOnWriteArrayList<?>)c).getArray();
    else {
        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);
}


public CopyOnWriteArrayList(E[] toCopyIn) {
    setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
}

---

2、添加元素

CopyOnWriteArrayList 容器 add 方法的处理过程大致如下：

对于 CopyOnWriteArrayList 这种容器来说，添加元素的操作是非常耗时的，因为它每次都会拷贝一个原数组的副本，然后对副本进行操作，操作完成之后再把 array 对象指向副本。在这个过程中，并不会对原数组进行修改，所以原数组是可以进行并发的读取的。最终，我们只能感知到 array 这个对象改变了，但是这个改变的过程我们是无法感知的，也就是说，它从一个一致性状态转变到了另一个一致性状态。

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

添加元素的方法除了上面的 add 之外，比较常用的操作还有：

//在指定位置添加元素
public void add(int index, E element);

//批量添加元素
public boolean addAll(Collection<? extends E> c);

//如果元素不存在，则添加
public boolean addIfAbsent(E e);

//如果元素不存在，则添加（批量）
public int addAllAbsent(Collection<? extends E> c);

批量添加元素的方法在 CopyOnWriteArrayList 容器中显得非常重要，比起 add 单个元素的添加，批量添加可以有效的减少 copy 副本的次数，提高效率。在前文说过“如果有初始化数据的话，千万不要用默认的构造方法创建一个空的容器，然后再一个个添加到里面。”这下子知道为什么了吧！

---

3、删除元素

删除元素的过程也是通过拷贝的方式来实现的，这里就不再详细解释了，其中 remove 方法的源码如下：

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 方法还有：

//删除第一个相等的元素
public boolean remove(Object o);

//批量删除元素
public boolean removeAll(Collection<?> c);

//过滤掉匹配的元素
public boolean removeIf(Predicate<? super E> filter);

---

4、修改元素

修改元素只有这一个方法，也是通过写时复制的方式，源码如下：

public E set(int index, E element) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        E oldValue = get(elements, index);

        if (oldValue != element) {
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len);
            newElements[index] = element;
            setArray(newElements);
        } else {
            // Not quite a no-op; ensures volatile write semantics
            setArray(elements);
        }
        return oldValue;
    } finally {
        lock.unlock();
    }
}

---

5、获取元素

通过写时复制的方式，CopyOnWriteArrayList 的 get 方法不用加锁也可以保证线程安全，所以 CopyOnWriteArrayList 并发读的效率是非常高的，它是直接通过数组下标获取元素的。源码如下：

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

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

四、总结

1、CopyOnWriteArrayList 是一个并发的数组容器，它的底层实现是数组。
2、CopyOnWriteArrayList 采用写时复制的方式来保证线程安全。
3、通过写时复制的方式，可以高效的进行并发读，但是对于写操作，每次都要进行加锁以及拷贝副本，效率非常低，所以 CopyOnWriteArrayList 仅适合读多写少的场景。