CopyOnWriteArrayList源码详解

1. CopyOnWriteArrayList概述

CopyOnWriteArrayList是线程安全集合，它内部通过一个数组存储元素。通过名字可以看出，这是一个“写时复制”的List，每次要修改该List的时候，都会new一个新的数组，copy原来数组元素到该新的数组，并在该新的数组上修改，修改完后，更新原有数组引用到该新的数组。

读的时候不需要加锁，读操作都是在原来数组上进行的，多线程可以并发的读。但是写是需要加锁的，否则多线程写会创建N个数组。读操作在原有数组进行，写操作在新的数组上进行，互不干扰，读写分离。

“写时复制”会带来很大性能问题，当写操作比较多时，每次修改都将new一个新的数组并将原来数组元素copy到该新的数组，效率较低，因此，CopyOnWriteArrayList适合读远多于写的场景。

看下CopyOnWriteArrayList类图：

CopyOnWriteArrayList实现了List、RandomAccess、Cloneable、Serializable接口。内部通过数组存储元素，因此它是一个“随机存取”的List。RandomAccess是一个空的接口，实现它仅仅标示CopyOnWriteArrayList是一个“随机存取”的List。

3. 构造方法

CopyOnWriteArrayList有三个构造方法，看下源码：

//“写”操作加锁
final transient ReentrantLock lock = new ReentrantLock();

//内部存储元素的数组
private transient volatile Object[] array;

//该方法和下面的setArray方法都是包访问权限，用户代码无法访问该方法，因此无法直接修改内部数组
//并且这两个方法都是final，无法被子类重写，避免数组被子类修改
final Object[] getArray() {
    return array;
}

final void setArray(Object[] a) {
    array = a;
}

//创建一个空的List
public CopyOnWriteArrayList() {
    setArray(new Object[0]);
}

//创建的List包括指定集合的元素
public CopyOnWriteArrayList(Collection<? extends E> c) {
    Object[] elements;
    //如果指定集合也是一个CopyOnWriteArrayList，将引用指向该集合的内部数组即可
    if (c.getClass() == CopyOnWriteArrayList.class)
      elements = ((CopyOnWriteArrayList<?>)c).getArray();
    else {
      elements = c.toArray();
      if (elements.getClass() != Object[].class)
        elements = Arrays.copyOf(elements, elements.length, Object[].class);
    }
    //设置引用
    setArray(elements);
}

//通过指定数组初始化CopyOnWriteArrayList，不能直接引用该数组，因为该数组可以被随意修改，
//必须重新创建一个数组并从指定的数组copy元素到新的数组
public CopyOnWriteArrayList(E[] toCopyIn) {
    setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
}

CopyOnWriteArrayList通过可重入锁ReentantLock，对写操作加锁，通过Object数组实现内部存储。

通过指定数组初始化时必须创建一个新的数组，而不能直接将数组引用指向参数数组，因为该参数数组可以被外部随意修改。

2. 增加方法

add方法

CopyOnWriteArrayList有很多增加元素的方法，这些方法都是“写”方法，修改之前需要加锁，首先看最简单的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();
    }
}

修改元素之前通过Arrays.copyOf方法拷贝一份数组，并在新的数组上修改，修改完后设置数组引用为新建的数组。

CopyOnWriteArrayList还有另外一个在指定位置增加元素的方法，思路基本相同，不再介绍。

接着看下addAll方法

addAll方法

该方法将指定集合的元素都添加到该CopyOnWriteArrayList，看下源码。

public boolean addAll(Collection<? extends E> c) {
    Object[] cs = (c.getClass() == CopyOnWriteArrayList.class) ?
      ((CopyOnWriteArrayList<?>)c).getArray() : c.toArray();
    if (cs.length == 0)
      return false;
    final ReentrantLock lock = this.lock;
    //写操作要加锁!
    lock.lock();
    try {
      Object[] elements = getArray();
      int len = elements.length;
      //如果本数组大小为0，将数组引用指向cs
      if (len == 0 && cs.getClass() == Object[].class)
        setArray(cs);
      else {
        //写时复制!
        //先将elements数组拷贝到一个更大的数组，然后将cs中的元素也拷贝到该更大的数组
        Object[] newElements = Arrays.copyOf(elements, len + cs.length);
        System.arraycopy(cs, 0, newElements, len, cs.length);
        setArray(newElements);
      }
      return true;
    } finally {
      //释放锁
      lock.unlock();
    }
}

方法很简单，关键点看注释即可。

还有一个在指定位置插入指定集合元素的方法，思路基本相同，不再讲解。

addAllAbsent

该方法有一个集合参数c，将c中不存在于该CopyOnWriteArrayList的元素加到该CopyOnWriteArrayList中。看下源码：

public int addAllAbsent(Collection<? extends E> c) {
    Object[] cs = c.toArray();
    if (cs.length == 0)
      return 0;
    final ReentrantLock lock = this.lock;
    //写操作必须加锁
    lock.lock();
    try {
      Object[] elements = getArray();
      int len = elements.length;
      int added = 0;
      //这个for循环将c中不存在于该CopyOnWriteArrayList的元素放到cs前面部分
      for (int i = 0; i < cs.length; ++i) {
        Object e = cs[i];
        //既不存在于当前CopyOnWriteArrayList的数组，也不存在于cs数组中
        if (indexOf(e, elements, 0, len) < 0 &&
            indexOf(e, cs, 0, added) < 0)
          cs[added++] = e;
      }
      //一次性将元素添加到CopyOnWriteArrayList的数组中
      if (added > 0) {
        Object[] newElements = Arrays.copyOf(elements, len + added);
        System.arraycopy(cs, 0, newElements, len, added);
        setArray(newElements);
      }
      return added;
    } finally {
      //释放锁
      lock.unlock();
    }
}

addAllAbsent将最终需要添加到该CopyOnWriteArrayList的元素放到一个数组中，然后一次性添加。

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;
      //numMoved=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 boolean remove(Object o) {
    Object[] snapshot = getArray();
    //找到元素o的位置
    int index = indexOf(o, snapshot, 0, snapshot.length);
    return (index < 0) ? false : remove(o, snapshot, index);
}

该方法删除指定的元素，而不是根据索引删除，首先调用indexOf方法找到该元素在数组中的索引，然后调用另一个重载的删除方法删除该元素。

removeAll

该方法有一个指定集合的参数，删除本List中所有存在于指定集合中的元素。看下源码：

//删除所有存在于集合c中的元素，返回该List是否改变
public boolean removeAll(Collection<?> c) {
    if (c == null) throw new NullPointerException();
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
      Object[] elements = getArray();
      int len = elements.length;
      if (len != 0) {
        int newlen = 0;
        Object[] temp = new Object[len];
        for (int i = 0; i < len; ++i) {
          Object element = elements[i];
          //说明当前元素不在指定的集合c中，不需要删除，放在临时数组中
          if (!c.contains(element))
            temp[newlen++] = element;
        }
        //数组有改变，copy一份临时数组并将引用设置为该数组
        if (newlen != len) {
          setArray(Arrays.copyOf(temp, newlen));
          return true;
        }
      }
      //未改变
      return false;
    } finally {
      lock.unlock();
    }
}

该方法的实现思路也很简单，将存在于指定集合的元素放在一个临时数组，最后copy一份该临时数组，重新设置CopyOnWriteArrayList的数组引用。

CopyOnWriteArrayList还有一个删除指定范围内元素的方法，不再讲解。

4. 迭代器

CopyOnWriteArrayList内部静态类COWIterator实现了迭代器，需要注意的是，这里的迭代器凡是修改操作都会抛出UnsupportedOperationException，即不能通过迭代器修改。看下源码：

static final class COWIterator<E> implements ListIterator<E> {
    //原数组的一个快照
    private final Object[] snapshot;
    //下一个元素的索引
    private int cursor;

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

    public boolean hasNext() {
      return cursor < snapshot.length;
    }

    public boolean hasPrevious() {
      return cursor > 0;
    }

    @SuppressWarnings("unchecked")
    public E next() {
      if (! hasNext())
        throw new NoSuchElementException();
      return (E) snapshot[cursor++];
    }

    @SuppressWarnings("unchecked")
    public E previous() {
      if (! hasPrevious())
        throw new NoSuchElementException();
      return (E) snapshot[--cursor];
    }

    public int nextIndex() {
      return cursor;
    }

    public int previousIndex() {
      return cursor-1;
    }

    //下面几个修改操作都抛出异常
    public void remove() {
      throw new UnsupportedOperationException();
    }

    public void set(E e) {
      throw new UnsupportedOperationException();
    }

    public void add(E e) {
      throw new UnsupportedOperationException();
    }

    //函数式编程的思想，遍历数组并处理该元素
    @Override
    public void forEachRemaining(Consumer<? super E> action) {
      Objects.requireNonNull(action);
      Object[] elements = snapshot;
      final int size = elements.length;
      for (int i = cursor; i < size; i++) {
        @SuppressWarnings("unchecked") E e = (E) elements[i];
        //处理该元素
        action.accept(e);
      }
      cursor = size;
    }
}

这个迭代器只能查看而不能做任务修改。注意forEachRemaining方法，该方法遍历数组元素并处理该元素，关于函数式编程，以后有机会再好好学习下。