CopyOnWriteArrayList源码解读

概述

CopyOnWriteArrayList是jdk concurrent包中提供的一个非阻塞型的，线程安全的List实现。

CopyOnWriteArrayList在进行数据修改时，都不会对数据进行锁定，每次修改时，先拷贝整个数组，然后修改其中的一些元素，完成上述操作后，替换整个数组的指针。

对CopyOnWriteArrayList进行读取时，也不进行数据锁定，直接返回需要查询的数据，如果需要返回整个数组，那么会将整个数组拷贝一份，再返回，保证内部array在任何情况下都是只读的。

应用场景

正因为上述读写特性，如果需要频繁对CopyOnWriteArrayList进行修改，而很少读取的话，那么会严重降低系统性能。

因为没有锁的干预，所以CopyOnWriteArrayLIst在少量修改，频繁读取的场景下，有很好的并发性能。

数据结构

CopyOnWriteArrayList中，包含一个array数组对象，这个对象，只能由getArray()和setArray()两个方法访问，源码如下：

    private volatile transient Object[] array;

    final Object[] getArray() {
        return array;
    }

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

并发安全保证

CopyOnWriteArrayList在并发情况下，可以提供高性能的并发读取，并且保证读取的内容一定是正确的，不受多线程并发问题影响的。在本文中，我们从构造函数的并发安全性、访问单个元素的并发安全性、访问整个数组的并发安全性和写操作的并发安全性，四个方面进行分析。

构造函数的并发安全性

CopyOnWriteArrayList提供了三个构造函数，分别为

• CopyOnWriteArrayList()：构造一个内容为空的对象
• CopyOnWriteArrayList(Collection<? extends E> c)：根据传入参数中的内容，构造一个新的对象
• CopyOnWriteArrayList(E[] toCopyIn)：根据传入数组中的内容，构造一个新的对象

上述三个方法的源码如下：

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

    /**
     * 根据传入参数c的长度，构造一个同样长度的Object[]对象，并且将c的内容，依次填入此Object[]对象中
     * 注意：
     *   1. 这里对于c中内容的复制，是浅拷贝而非深拷贝
     *   2. 这里的构造函数，未显式判断c是否为null，实际上如果c为null，会抛出空指针异常
     */
    public CopyOnWriteArrayList(Collection<? extends E> c) {
 Object[] elements = c.toArray();
 if (elements.getClass() != Object[].class)
     elements = Arrays.copyOf(elements, elements.length, Object[].class);
 setArray(elements);
    }

    /**
     * 根据传入参数的长度，构造出一个同样长度，内容一致的数组对象，封装在CopyOnWriteArrayList中
     * 注意：
     *   1. 这里对于数组内容的复制，是浅拷贝而非深拷贝
     *   2. 这里的构造函数，未显式判断传入参数是否为null，实际上如果传入参数为null，会抛出空指针异常
     */
    public CopyOnWriteArrayList(E[] toCopyIn) {
 setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
    }

访问单个元素的并发安全性

访问单个元素时，不会对原有数组造成任何影响，所以肯定是线程安全的。这里列举一两个方法的实现源码，其他的不再赘述：

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

    public int indexOf(Object o) {
        /* 
         * 在取数组元素前，获取当前时刻array对象的引用至关重要 
         * 在后续文章描述中可以知道，CopyOnArrayList在set操作时，会更新array对象的引用
         * 这里如果不事先获得引用，那么后面实际的indexOf操作，会因为并发问题，得到意想不到的结果，还可能出现数组越界异常
         */
        Object[] elements = getArray();  
        return indexOf(o, elements, 0, elements.length);
    }

    private static int indexOf(Object o, Object[] elements,
                               int index, int fence) {
        if (o == null) {
            for (int i = index; i < fence; i++)
                if (elements[i] == null)
                    return i;
        } else {
            for (int i = index; i < fence; i++)
                if (o.equals(elements[i]))
                    return i;
        }
        return -1;
    }

访问整个数组的并发安全性

访问整个数组的操作，包括clone以及toArray方法，这些方法在执行时，不会直接返回内部封装的array对象引用，而是将其拷贝一份，再返回。注意，这里的拷贝，也是浅拷贝。

源码如下： www.520xunlong.com

    public Object[] toArray() {
        Object[] elements = getArray();
 return Arrays.copyOf(elements, elements.length);
    }

    public <T> T[] toArray(T a[]) {
        Object[] elements = getArray();
        int len = elements.length;
        if (a.length < len)
     return (T[]) Arrays.copyOf(elements, len, a.getClass());
 else {
     System.arraycopy(elements, 0, a, 0, len);
     if (a.length > len)
  a[len] = null;
     return a;
 }
    }

    public Object clone() {
        try {
            CopyOnWriteArrayList c = (CopyOnWriteArrayList)(super.clone());
            c.resetLock();
            return c;
        } catch (CloneNotSupportedException e) {
            /* 实际不会发生，但因为clone()接口声明返回此异常，所以这里会这样写 */
            throw new InternalError();
        }
    }

写操作的并发安全性

写操作的并发安全性，是CopyOnWriteArrayList中最重要的一点，只有保证写操作是安全的，才能保证并发是安全的。

set方法，是写操作的一个基本方法，其源码如下：

    public E set(int index, E element) {
 final ReentrantLock lock = this.lock;
 lock.lock();  /* 锁定整个数组，不允许其他写操作同时进行，否则会出现丢失更新的问题 */
 try {
     Object[] elements = getArray();
     Object oldValue = 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 
                 * 个人理解，这个地方没什么作用，只是为了部全set的语义
                 */
  setArray(elements);
     }
     return (E)oldValue;
 } finally {
     lock.unlock();
 }
    }

为list末尾添加一个新元素，使用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();
 }
    }

同时，也可以将某个元素加入到某个特定的位置，如下所示：

    public void add(int index, E element) {
 final ReentrantLock lock = this.lock;
 lock.lock();
 try {
     Object[] elements = getArray();
     int len = elements.length;
            /* 这个判断必须放到lock内，否则在多线程并发访问条件下，可能会出现错误，
             * 例如，一个线程判断其不会抛出异常，另一个线程立即修改了数组长度，导致后续操作均会失败
             */
     if (index > len || index < 0)
  throw new IndexOutOfBoundsException("Index: "+index+
          ", Size: "+len);
     Object[] newElements;
     int numMoved = len - index;
     if (numMoved == 0) { /* 插入元素的位置，在数组末尾 */
  newElements = Arrays.copyOf(elements, len + 1);
            }
     else {
                /* 插入元素的位置，在数组中间 */
  newElements = new Object[len + 1];
  System.arraycopy(elements, 0, newElements, 0, index);
  System.arraycopy(elements, index, newElements, index + 1,
     numMoved);
     }
     newElements[index] = element;
     setArray(newElements);
 } finally {
     lock.unlock();
 }
    }

CopyOnWriteArrayList同时也提供了从list中，移除某个元素的方法，源码如下：

    public E remove(int index) {
 final ReentrantLock lock = this.lock;
 lock.lock();
 try {
     Object[] elements = getArray();
     int len = elements.length;
     Object oldValue = 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 (E)oldValue;
 } finally {
     lock.unlock();
 }
    }

也可以直接移除list中的某个对象，源码如下：

    public boolean remove(Object o) {
 final ReentrantLock lock = this.lock;
 lock.lock();
 try {
     Object[] elements = getArray();
     int len = elements.length;
     if (len != 0) {
  // Copy while searching for element to remove
  // This wins in the normal case of element being present
  int newlen = len - 1;
  Object[] newElements = new Object[newlen];

  for (int i = 0; i < newlen; ++i) {
      if (eq(o, elements[i])) {
   /* 如果需要移除的元素在数组中间，那么直接将后面的所有元素向前移动 */
   for (int k = i + 1; k < len; ++k) {
       newElements[k-1] = elements[k];
                        }
   setArray(newElements);
   return true;  /* 找到了需要删除的元素，并正常删除，返回true */
      } else {
   newElements[i] = elements[i];
                    }
  }

  /* 当需要移除的元素，在数组最后，直接将新的数组赋值过去 */
  if (eq(o, elements[newlen])) {
      setArray(newElements);
      return true;
  }
     }
            /* 未找到需要删除的元素，返回false */
     return false;
 } finally {
     lock.unlock();
 }
    }

其他修改的方法，原理上都是类似的，这里不再赘述。ss