深刻Java集合学习系列：CopyOnWriteArrayList详解

http://my.oschina.net/jielucky/blog/167198

http://my.oschina.net/summerpxy/blog/405728

CopyOnWriteArrayList是ArrayList 的一个线程安全的变体，其中全部可变操做（add、set等等）都是经过对底层数组进行一次新的复制来实现的。

     这通常须要很大的开销，可是当遍历操做的数量大大超过可变操做的数量时，这种方法可能比其余替代方法更 有效。在不能或不想进行同步遍历，但又须要从并发线程中排除冲突时，它也颇有用。“快照”风格的迭代器方法在建立迭代器时使用了对数组状态的引用。此数组在迭代器的生存期内不会更改，所以不可能发生冲突，而且迭代器保证不会抛出ConcurrentModificationException。建立迭代器之后，迭代器就不会反映列表的添加、移除或者更改。在迭代器上进行的元素更改操做（remove、set和add）不受支持。这些方法将抛出UnsupportedOperationException。容许使用全部元素，包括null。

    内存一致性效果：当存在其余并发 collection 时，将对象放入CopyOnWriteArrayList以前的线程中的操做 happen-before 随后经过另外一线程从CopyOnWriteArrayList中访问或移除该元素的操做。 

   这种状况通常在多线程操做时，一个线程对list进行修改。一个线程对list进行fore时会出现java.util.ConcurrentModificationException错误。

   下面来看一个列子：两个线程一个线程fore一个线程修改list的值。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

package com.lucky.concurrent.list;   import java.util.ArrayList; import java.util.List; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors;   public class CopyOnWriteArrayListDemo {      /**       * 读线程       * @author wangjie       *       */      private static class ReadTask implements Runnable {          List<String> list;            public ReadTask(List<String> list) {              this .list = list;          }            public void run() {              for (String str : list) {                  System.out.println(str);              }          }      }      /**       * 写线程       * @author wangjie       *       */      private static class WriteTask implements Runnable {          List<String> list;          int index;            public WriteTask(List<String> list, int index) {              this .list = list;              this .index = index;          }            public void run() {              list.remove(index);              list.add(index, "write_" + index);          }      }        public void run() {          final int NUM = 10 ;          List<String> list = new ArrayList<String>();          for ( int i = 0 ; i < NUM; i++) {              list.add( "main_" + i);          }          ExecutorService executorService = Executors.newFixedThreadPool(NUM);          for ( int i = 0 ; i < NUM; i++) {              executorService.execute( new ReadTask(list));              executorService.execute( new WriteTask(list, i));          }          executorService.shutdown();      }        public static void main(String[] args) {          new CopyOnWriteArrayListDemo().run();      } }

运行结果： 

从结果中能够看出来。在多线程状况下报错。其缘由就是多线程操做结果：那这个种方案不行咱们就换个方案。用jdk自带的类CopyOnWriteArrayList来作容器。这个类和ArrayList最大的区别就是add(E) 的时候。容器会自动copy一份出来而后再尾部add(E)。看源码：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

/**      * Appends the specified element to the end of this list.      *      * @param e element to be appended to this list      * @return <tt>true</tt> (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();     }     }

用到了Arrays.copyOf 方法。这样致使每次操做的都不是同一个引用。也就不会出现java.util.ConcurrentModificationException错误。
换了种方案看代码：

?

1 2	//      List<String> list = new ArrayList<String>();          CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();

也就把容器list换成了  CopyOnWriteArrayList，其余的没变。 线程里面的list不用改。由于  CopyOnWriteArrayList实现的也是list<E> 接口。看结果：

其结果没报错。
CopyOnWriteArrayList add(E) 和remove(int index)都是对新的数组进行修改和新增。因此在多线程操做时不会出现java.util.ConcurrentModificationException错误。
因此最后得出结论：CopyOnWriteArrayList适合使用在读操做远远大于写操做的场景里，好比缓存。发生修改时候作copy，新老版本分离，保证读的高性能，适用于以读为主的状况。

     CopyOnWriteArrayList类是高效的线程安全的类。线程安全是由于该类对于全部的修改方法都使用了加锁操做。高效是由于对于迭代操做是对原有集合的引用，避免了同步的开销。

     

?

1 2 3 4 5

/** The lock protecting all mutators */      transient  final  ReentrantLock lock =  new  ReentrantLock();        /** The array, accessed only via getArray/setArray. */      private  volatile  transient  Object[] array;

   这两个成员变量是该类的核心，对集合全部的修改操做都须要使用lock加锁，array则是整个集合的数据储存部分，关键在于该array被声明为volatile，当一个线程对与线程中array副本的修改会当即同步到主内存中该变量中去。

  

?

1 2 3 4 5 6 7

public  CopyOnWriteArrayList(Collection<?  extends  E> c) {          Object[] 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);      }

再来看构造函数，构造函数会将传进来的集合经过Arrays.copyOf()方法转换成一个Object类型的数组，并用array成员变量存储起来。

再来讲说add方法。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

public  void  add( int  index, E element) {          final  ReentrantLock lock =  this .lock;          lock.lock();          try  {              Object[] elements = getArray();              int  len = elements.length;              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();          }      }

在对数据进行插入以前，经过该lock.lock()方法对代码块加锁，经过比较index和length之间的位置，判断出须要移位的数目，最后经过System.arraycopy()方法，从新生产一个新的newElements数组，而后将该数组传递给array成员变量保存。

?

1 2 3

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

而get方法则是取得该线程当前拥有的array数组，不须要额外的同步开销。

为何get方法不须要同步呢？这正是CopyOnWriteArrayList的高效之处，在多线程环境下，每个线程中都有一个主内存中变量的拷贝，该拷贝反映的是此时此刻主内存中该集合的状况。当线程开始运行时，一个线程会修改该集合，例如使用add方法，这个时候该线程内部的array变量就会修改，因为该变量是volatile的，因此此时该线程中修改的值会被当即同步到主内存中该变量中去。可是若是一个线程是在这个修改以前建立的，那么该线程内部所拥有的程序变量array仍是改变以前的。全部对于CopyOnWriteArrayList类中的读取操做可能并不能真实的反映出此时此刻主内存块中的变量的状况，所以也不须要同步的开销。