由ArrayList来深入理解Java中的fail-fast机制

import java.util.*;import java.util.concurrent.*;/* * @desc java集合中Fast-Fail的测试程序。 * * fast-fail事件产生的条件：当多个线程对Collection进行操作时，若其中某一个线程通过iterator去遍历集合时，该集合的内容被其他线程所改变；则会抛出ConcurrentModificationException异常。 * fast-fail解决办法：通过util.concurrent集合包下的相应类去处理，则不会产生fast-fail事件。 * * 本例中，分别测试ArrayList和CopyOnWriteArrayList这两种情况。ArrayList会产生fast-fail事件，而CopyOnWriteArrayList不会产生fast-fail事件。 * (01) 使用ArrayList时，会产生fast-fail事件，抛出ConcurrentModificationException异常；定义如下： *   private static List<String> list = new ArrayList<String>(); * (02) 使用时CopyOnWriteArrayList，不会产生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，每添加一个数之后，就通过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，每添加一个数之后，就通过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修改的次数：每修改一次(添加/删除等操作)，将modCount+1 protected transient int modCount = 0; // 返回List对应迭代器。实际上，是返回Itr对象。 public Iterator<E> iterator() {  return new Itr(); } // Itr是Iterator(迭代器)的实现类 private class Itr implements Iterator<E> {  int cursor = 0;  int lastRet = -1;  // 修改数的记录值。  // 每次新建Itr()对象时，都会保存新建该对象时对应的modCount；  // 以后每次遍历List中的元素的时候，都会比较expectedModCount和modCount是否相等；  // 若不相等，则抛出ConcurrentModificationException异常，产生fail-fast事件。  int expectedModCount = modCount;  public boolean hasNext() {   return cursor != size();  }  public E next() {   // 获取下一个元素之前，都会判断“新建Itr对象时保存的modCount”和“当前的modCount”是否相等；   // 若不相等，则抛出ConcurrentModificationException异常，产生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中容量变化时，对应的同步函数 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 { ... // 返回集合对应的迭代器 public Iterator<E> iterator() {  return new集合类中的fast-fail实现方式都差不多，我们以最简单的ArrayList为例吧。protected transient int modCount = 0;记录的是我们对ArrayList修改的次数，比如我们调用 add(),remove()等改变数据的操作时，会将modCount++。protected transient int modCount = 0;记录的是我们对ArrayList修改的次数，比如我们调用 add(),remove()等改变数据的操作时，会将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时，将集合中的元素保存到一个新的拷贝数组中。   // 这样，当原始集合的数据改变，拷贝数据中的值也不会变化。   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();  } } ...}