快速失败机制

定义

通过迭代器遍历一个集合对象时，如果在遍历过程中对集合对象进行了修改，则在下一次迭代时会抛出ConcureentModificationException.

原理

每个集合对象都有一个modCount值，每一次对集合进行修改，modCount值都会加1。准备对过迭代器对集合进进行遍历时，首先会设置expectedModCount值等于当前modCount值，然后每一次迭代都会对expectedModCount与最新的modCount值进行比较，如果两者相同则继续，否则就会导出ConcurentModificationException.

触发modCount++

以ArrayList的源码为例，查看哪些操作会触发modCount++
1. 容量整理
下面展示一些相关的源代码。

public void trimToSize() {
     
        modCount++;
        if (size < elementData.length) {
     
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

2. 扩容

     private void ensureExplicitCapacity(int minCapacity) {
     
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

3. 根据下标删除元素

 public E remove(int index) {
     
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

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

        return oldValue;
    }

4. 根据元素对象删除

    public boolean remove(Object o) {
     
        if (o == null) {
     
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
     
                    fastRemove(index);
                    return true;
                }
        } else {
     
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
     
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

5. 清空集合

    public void clear() {
     
        modCount++;

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

6. 在未尾添加参数集合中的元素

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

7. 在指定的位置开始添加

   public boolean addAll(int index, Collection<? extends E> c) {
     
        rangeCheckForAdd(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount

        int numMoved = size - index;
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);

        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }

8. 清除指定范围元素

    protected void removeRange(int fromIndex, int toIndex) {
     
        modCount++;
        int numMoved = size - toIndex;
        System.arraycopy(elementData, toIndex, elementData, fromIndex,
                         numMoved);

        // clear to let GC do its work
        int newSize = size - (toIndex-fromIndex);
        for (int i = newSize; i < size; i++) {
     
            elementData[i] = null;
        }
        size = newSize;
    }

9. 清除参数集合中包含的元素

 public boolean removeAll(Collection<?> c) {
     
        Objects.requireNonNull(c);
        return batchRemove(c, false);
    }

10. 清除不包含在参数集合中的元素

    public boolean retainAll(Collection<?> c) {
     
        Objects.requireNonNull(c);
        return batchRemove(c, true);
    }

11. 根据条件清除
基于方法太长，仅列方法的声明

 @Override
    public boolean removeIf(Predicate<? super E> filter)；

12. 元素替换

    @Override
    @SuppressWarnings("unchecked")
    public void replaceAll(UnaryOperator<E> operator) {
     
        Objects.requireNonNull(operator);
        final int expectedModCount = modCount;
        final int size = this.size;
        for (int i=0; modCount == expectedModCount && i < size; i++) {
     
            elementData[i] = operator.apply((E) elementData[i]);
        }
        if (modCount != expectedModCount) {
     
            throw new ConcurrentModificationException();
        }
        modCount++;
    }

13. 元素排序

    @Override
    @SuppressWarnings("unchecked")
    public void sort(Comparator<? super E> c) {
     
        final int expectedModCount = modCount;
        Arrays.sort((E[]) elementData, 0, size, c);
        if (modCount != expectedModCount) {
     
            throw new ConcurrentModificationException();
        }
        modCount++;
    }

一边遍历一边修改

以上的方法都会修改modCount，而修改必须为触发modCount++，为了防止ConcurrentModificationException,有两个思路：
一、防止expectedModCount与modCount比较。
二、将expectedModCount更新为最新的modCount
两种方式的实现代码如下：
代码一：从前往后遍历，不比较

		List<String> list = new ArrayList<String>();
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		
		//从前往后遍历，不比较
		for( int i = 0; i < list.size(); i ++ ){
     
			String temp = list.get( i );
			if( "bbb".equals( temp ) ){
     
				list.remove( i );
				i --;
			}
			else{
     
				System.out.println( temp );
			}
		}

代码二，从后往前遍历，不比较

		List<String> list = new ArrayList<String>();
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		
		//从后往前遍历， 不比较
		for( int i = list.size() - 1 ; i >= 0; i -- ){
     
			String temp = list.get( i );
			if( "bbb".equals( temp ) ){
     
				list.remove( i );
			}
			else{
     
				System.out.println( temp );
			}
		}

代码三，重置迭代器（这种方式会导致一定的遍历重复，可以通过代码实现去重）

		List<String> list = new ArrayList<String>();
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		
		//遍历
		Iterator<String> it = list.iterator();
		while( it.hasNext() ){
     
			String temp = it.next();
			if( "bbb".equals( temp ) ){
     
				list.remove( temp );
				//会导致前续元素重复遍历
				it = list.iterator();
			}
			else{
     
				System.out.println(temp);
			}
		}

安全失败机制

当需要对集合进行修改时，先copy一个集合的副本，对集合的副本进行修改，这样因为没有对原集合进行操作，所以不会触发原集合的modCount++,也就不会触发CocurrentModificationException.这种方式的缺点是：原集合在遍历过程中，无法获取到修改后的数据。
java.util.concurrent下的包都是安全失败的，可以并发的使用。