import java.util.*;
import java.util.concurrent.*;

/*
 * @desc java集合中Fast-Fail的測試程序。
 *
 * fast-fail事件產(chǎn)生的條件：當(dāng)多個線程對Collection進行操作時，若其中某一個線程通過iterator去遍歷集合時，該集合的內(nèi)容被其他線程所改變；則會拋出ConcurrentModificationException異常。
 * fast-fail解決辦法：通過util.concurrent集合包下的相應(yīng)類去處理，則不會產(chǎn)生fast-fail事件。
 *
 * 本例中，分別測試ArrayList和CopyOnWriteArrayList這兩種情況。ArrayList會產(chǎn)生fast-fail事件，而CopyOnWriteArrayList不會產(chǎn)生fast-fail事件。
 * (01) 使用ArrayList時，會產(chǎn)生fast-fail事件，拋出ConcurrentModificationException異常；定義如下：
 *   private static List<String> list = new ArrayList<String>();
 * (02) 使用時CopyOnWriteArrayList，不會產(chǎn)生fast-fail事件；定義如下：
 *   private static List<String> list = new CopyOnWriteArrayList<String>();
 *
 * @author skywang
 */
public class FastFailTest {

 private static List<String> list = new ArrayList<String>();
 //private static List<String> list = new CopyOnWriteArrayList<String>();
 public static void main(String[] args) {

  // 同時啟動兩個線程對list進行操作！
  new ThreadOne().start();
  new ThreadTwo().start();
 }

 private static void printAll() {
  System.out.println("");

  String value = null;
  Iterator iter = list.iterator();
  while(iter.hasNext()) {
   value = (String)iter.next();
   System.out.print(value+", ");
  }
 }

 /**
  * 向list中依次添加0,1,2,3,4,5，每添加一個數(shù)之后，就通過printAll()遍歷整個list
  */
 private static class ThreadOne extends Thread {
  public void run() {
   int i = 0;
   while (i<6) {
    list.add(String.valueOf(i));
    printAll();
    i++;
   }
  }
 }

 /**
  * 向list中依次添加10,11,12,13,14,15，每添加一個數(shù)之后，就通過printAll()遍歷整個list
  */
 private static class ThreadTwo extends Thread {
  public void run() {
   int i = 10;
   while (i<16) {
    list.add(String.valueOf(i));
    printAll();
    i++;
   }
  }
 }

}

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {

 ...

 // AbstractList中唯一的屬性
 // 用來記錄List修改的次數(shù)：每修改一次(添加/刪除等操作)，將modCount+1
 protected transient int modCount = 0;

 // 返回List對應(yīng)迭代器。實際上，是返回Itr對象。
 public Iterator<E> iterator() {
  return new Itr();
 }

 // Itr是Iterator(迭代器)的實現(xiàn)類
 private class Itr implements Iterator<E> {
  int cursor = 0;

  int lastRet = -1;

  // 修改數(shù)的記錄值。
  // 每次新建Itr()對象時，都會保存新建該對象時對應(yīng)的modCount；
  // 以后每次遍歷List中的元素的時候，都會比較expectedModCount和modCount是否相等；
  // 若不相等，則拋出ConcurrentModificationException異常，產(chǎn)生fail-fast事件。
  int expectedModCount = modCount;

  public boolean hasNext() {
   return cursor != size();
  }

  public E next() {
   // 獲取下一個元素之前，都會判斷“新建Itr對象時保存的modCount”和“當(dāng)前的modCount”是否相等；
   // 若不相等，則拋出ConcurrentModificationException異常，產(chǎn)生fail-fast事件。
   checkForComodification();
   try {
    E next = get(cursor);
    lastRet = cursor++;
    return next;
   } catch (IndexOutOfBoundsException e) {
    checkForComodification();
    throw new NoSuchElementException();
   }
  }

  public void remove() {
   if (lastRet == -1)
    throw new IllegalStateException();
   checkForComodification();

   try {
    AbstractList.this.remove(lastRet);
    if (lastRet < cursor)
     cursor--;
    lastRet = -1;
    expectedModCount = modCount;
   } catch (IndexOutOfBoundsException e) {
    throw new ConcurrentModificationException();
   }
  }

  final void checkForComodification() {
   if (modCount != expectedModCount)
    throw new ConcurrentModificationException();
  }
 }

 ...
}

package java.util;

public class ArrayList<E> extends AbstractList<E>
  implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{

 ...

 // list中容量變化時，對應(yīng)的同步函數(shù)
 public void ensureCapacity(int minCapacity) {
  modCount++;
  int oldCapacity = elementData.length;
  if (minCapacity > oldCapacity) {
   Object oldData[] = elementData;
   int newCapacity = (oldCapacity * 3)/2 + 1;
   if (newCapacity < minCapacity)
    newCapacity = minCapacity;
   // minCapacity is usually close to size, so this is a win:
   elementData = Arrays.copyOf(elementData, newCapacity);
  }
 }


 // 添加元素到隊列最后
 public boolean add(E e) {
  // 修改modCount
  ensureCapacity(size + 1); // Increments modCount!!
  elementData[size++] = e;
  return true;
 }


 // 添加元素到指定的位置
 public void add(int index, E element) {
  if (index > size || index < 0)
   throw new IndexOutOfBoundsException(
   "Index: "+index+", Size: "+size);

  // 修改modCount
  ensureCapacity(size+1); // Increments modCount!!
  System.arraycopy(elementData, index, elementData, index + 1,
    size - index);
  elementData[index] = element;
  size++;
 }

 // 添加集合
 public boolean addAll(Collection<? extends E> c) {
  Object[] a = c.toArray();
  int numNew = a.length;
  // 修改modCount
  ensureCapacity(size + numNew); // Increments modCount
  System.arraycopy(a, 0, elementData, size, numNew);
  size += numNew;
  return numNew != 0;
 }


 // 刪除指定位置的元素 
 public E remove(int index) {
  RangeCheck(index);

  // 修改modCount
  modCount++;
  E oldValue = (E) elementData[index];

  int numMoved = size - index - 1;
  if (numMoved > 0)
   System.arraycopy(elementData, index+1, elementData, index, numMoved);
  elementData[--size] = null; // Let gc do its work

  return oldValue;
 }


 // 快速刪除指定位置的元素 
 private void fastRemove(int index) {

  // 修改modCount
  modCount++;
  int numMoved = size - index - 1;
  if (numMoved > 0)
   System.arraycopy(elementData, index+1, elementData, index,
        numMoved);
  elementData[--size] = null; // Let gc do its work
 }

 // 清空集合
 public void clear() {
  // 修改modCount
  modCount++;

  // Let gc do its work
  for (int i = 0; i < size; i++)
   elementData[i] = null;

  size = 0;
 }

 ...
}

package java.util.concurrent;
import java.util.*;
import java.util.concurrent.locks.*;
import sun.misc.Unsafe;

public class CopyOnWriteArrayList<E>
 implements List<E>, RandomAccess, Cloneable, java.io.Serializable {

 ...

 // 返回集合對應(yīng)的迭代器
 public Iterator<E> iterator() {
  return new集合類中的fast-fail實現(xiàn)方式都差不多，我們以最簡單的ArrayList為例吧。protected transient int modCount = 0;記錄的是我們對ArrayList修改的次數(shù)，比如我們調(diào)用 add(),remove()等改變數(shù)據(jù)的操作時，會將modCount++。protected transient int modCount = 0;記錄的是我們對ArrayList修改的次數(shù)，比如我們調(diào)用 add(),remove()等改變數(shù)據(jù)的操作時，會將modCount++。 COWIterator<E>(getArray(), 0);
 }

 ...

 private static class COWIterator<E> implements ListIterator<E> {
  private final Object[] snapshot;

  private int cursor;

  private COWIterator(Object[] elements, int initialCursor) {
   cursor = initialCursor;
   // 新建COWIterator時，將集合中的元素保存到一個新的拷貝數(shù)組中。
   // 這樣，當(dāng)原始集合的數(shù)據(jù)改變，拷貝數(shù)據(jù)中的值也不會變化。
   snapshot = elements;
  }

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

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

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

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

 ...

}