copyonwritearraylist 深究

除了加锁外，其实还有一种方式可以防止并发修改异常，这就是将读写分离技术（不是数据库上的）。

先回顾一下一个常识：

1、JAVA中“=”操作只是将引用和某个对象关联，假如同时有一个线程将引用指向另外一个对象，一个线程获取这个引用指向的对象，那么他们之间不会发生ConcurrentModificationException，他们是在虚拟机层面阻塞的，而且速度非常快，几乎不需要CPU时间。

2、JAVA中两个不同的引用指向同一个对象，当第一个引用指向另外一个对象时，第二个引用还将保持原来的对象。

 

基于上面这个常识，我们再来探讨下面这个问题：

在CopyOnWriteArrayList里处理写操作（包括add、remove、set等）是先将原始的数据通过JDK1.6的Arrays.copyof()来生成一份新的数组

然后在新的数据对象上进行写，写完后再将原来的引用指向到当前这个数据对象（这里应用了常识1），这样保证了每次写都是在新的对象上（因为要保证写的一致性，这里要对各种写操作要加一把锁，JDK1.6在这里用了重入锁），

然后读的时候就是在引用的当前对象上进行读（包括get，iterator等），不存在加锁和阻塞，针对iterator使用了一个叫 COWIterator的阉割版迭代器，因为不支持写操作，当获取CopyOnWriteArrayList的迭代器时，是将迭代器里的数据引用指向当前引用指向的数据对象，无论未来发生什么写操作，都不会再更改迭代器里的数据对象引用，所以迭代器也很安全（这里应用了常识2）。

CopyOnWriteArrayList中写操作需要大面积复制数组，所以性能肯定很差，但是读操作因为操作的对象和写操作不是同一个对象，读之间也不需要加锁，读和写之间的同步处理只是在写完后通过一个简单的“=”将引用指向新的数组对象上来，这个几乎不需要时间，这样读操作就很快很安全，适合在多线程里使用，绝对不会发生ConcurrentModificationException ，所以最后得出结论：CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里，比如缓存。

 

 

 

 

 

   在你的应用中有一个列表（List），它被频繁的遍历，但是很少被修改。像“你的主页上的前十个分类，它被频繁的访问，但是每个小时通过Quartz的Job来调度更新”。

如果你使用ArrayList来作为该列表的数据结构并且不使用同步（synchronization），你可能会遇到ConcurrentModificationException，因为在你使用Quartz的Job修改该列表时，其他的代码可能正在遍历该列表。

 

    有些开发人员可能使用Vector或Collections.synchronizedList(List<T>)的方式来解决该问题。但是这并没有效果!虽然在列表上add(),remove()和get()方法现在对线程是安全的，但遍历时仍然会抛出ConcurrentModificationException！在你遍历在列表时，你需要在该列表上使用同步，同时，在使用Quartz修改它时，也需要使用同步机制。这对性能和可扩展性来说是一个噩梦。同步需要在所有的地方出现，仅仅是因为每个小时都需要做更新。

 

     幸运的是，这里有更好的解决方案。使用CopyOnWriteArrayList。

当列表上的一个结构修改发生时，一个新的拷贝（copy）就会被创建。这在经常发生修改的地方使用，将会很低效。遍历该列表将不会出现ConcurrentModificationException，因为该列表在遍历时将不会被做任何的修改。

另一种避免添加同步代码但可以避免并发修改问题的方式是在调度任务中构建一个新的列表，然后将原来指向到列表上的引用赋值给新的列表。在JVM中，赋值一个新的引用是原子操作。这种方式在使用旧的遍历方式（for (int i=0; i<list.size(); i++) { … list.get(i) …}）时将无效（也会出错）。切换的列表中的大小将引发新的错误产生。更加糟糕的是因为改变是在不同的线程中发生的，所以还会有很多潜在的问题。使用volatile关键字可能会有所帮助，但是对列表大小的改变依然会有问题。

 

     内存一致性和刚发生后保证了CopyOnWriteArrayList的可用性。同时，代码变得更简单，因为根本不需要使用volatile关键字或同步。更少的代码，更少的bug！

 

     CopyOnWriteArrayList的另一个使用案例是观察者设计模式。如果事件监听器由多个不同的线程添加和移除，那么使用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对象引用，而是将其拷贝一份，再返回。注意，这里的拷贝，也是浅拷贝。

源码如下：

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

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