深刻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類中的讀取操做可能並不能真實的反映出此時此刻主內存塊中的變量的狀況，所以也不須要同步的開銷。