fast-fail机制

什么是fail-fast

    “快速失败”也就是fail-fast，它是Java集合的一种错误检测机制。在集合中经常遇到 java.util.ConcurrentModificationException异常，而产生这个原因就是fail-fast，主要发生在集合的迭代输出时，而在此时可能这个集合的内部结构已经发生改变，所以快速失败迭代器会尽最大努力抛出ConcurrentModificationException，以防止未知结果的发生。产生条件有如下两种情况:

(1)假设存在两个线程（线程1、线程2），线程1通过Iterator在遍历集合A中的元素，在某个时候线程2修改了集合A的结构，那么这个时候程序就可能会抛出 ConcurrentModificationException 异常
(2)在同一集合A中，如果正在迭代遍历集合A时，同时修改集合中的内容，就会抛出 ConcurrentModificationException 异常

fail-fast产生实例

单个线程的操作，我们看如下实例：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("xiaotang");
        list.add("java");
        list.add("c++");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String str = iterator.next();
            if ("xiaotang".equals(str)) {
                list.remove(str);
            }
        }
        for (String str : list) {
            System.out.println(str);
        }
    }
}

大家觉的输出结果是什么?

java
c++

其实真实结果如下:

Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(Unknown Source)
    at java.util.ArrayList$Itr.next(Unknown Source)
    at Test.main(Test.java:13)
xiaotang

为什么会是这样的结果，我们在后面再去详细说明,接着我们再看一个多个线程的产生fast-fail的事例.

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test {
    private List<integer> list = new ArrayList<integer>();
    /**
     * 初始化集合
     */
    public void initList() {
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
    }
    /**
     * 执行线程1,遍历List集合,并设置线程休眠
     */
    public void executeMethod1() {
        new Thread(new Runnable() {
            public void run() {
                // TODO 自动生成的方法存根
                Iterator iterator = list.iterator();
                while (iterator.hasNext()) {
                    System.out.println(iterator.next());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO 自动生成的 catch 块
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }
    /**
     * 执行线程2,修改List集合
     */
    public void executeMethod2() {
        new Thread(new Runnable() {
            public void run() {
                // TODO 自动生成的方法存根
                list.remove(3);
            }
        }).start();
    }
    public static void main(String[] args) {
        Test test = new Test();
        test.initList();
        test.executeMethod1();
        test.executeMethod2();
    }
}</integer></integer>

这个程序运行结果如下：(需要说明的是，这种结果是可能发生的,不是一定)

   
0
Exception in thread "Thread-0" java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(Unknown Source)
    at java.util.ArrayList$Itr.next(Unknown Source)
    at Test$1.run(Test.java:27)
    at java.lang.Thread.run(Unknown Source)  

产生的具体原因，我们会在下面详细讲到！

fast-fail产生过程以及原理分析

    我们查看AbstractList类就会发现有这样的变量:protected transient int modCount = 0;我们再看看其Iterator类,申明了expectedModeCount==modCount,判断是否产生了fast-fail,其实判断就是判断expectedModeCount是否与modCount相等.不相等就会产生fast-fail.所以在某个过程中，两个数值改变了就会导致不相等了。而在List中,add(),remove()等操作都会改变modCount,我们再来仔细的查看上面事例产生的具体原因。
     

 while (iterator.hasNext()) {
            String str = iterator.next();
            if ("xiaotang".equals(str)) {
                list.remove(str);
            }
        }

在迭代的过程中，会通过list.remove(str)，我们点开remove()源码:

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

点开 fastRemove(index)方法：

    private void fastRemove(int index) {
        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
    }

可以看到，modCount的值在这里面增加了1.我们再来看看，iterator.next(）做了什么：

	public E next() {
            checkForComodification();
	    try {
		E next = get(cursor);
		lastRet = cursor++;
		return next;
	    } catch (IndexOutOfBoundsException e) {
		checkForComodification();
		throw new NoSuchElementException();
	    }
	}

点开checkForComodification()方法：

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

可以看到这个方法就是判断modCount是否与expectedMoCount是否相等.不相等就会抛出ConcurrentModificationException异常。终于找到了根本原因了。所以, 不推荐我们在遍历集合的时候,又去修改集合的结构,可以大家就会问了,如果我们就是要通过迭代,去找到集合的内容，然后去remove掉这个元素呢?我们可以通过如下方法：

  Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String str = iterator.next();
            if ("xiaotang".equals(str)) {
                iterator.remove();
            }
        }

看到区别没，通过iterator.remove()就可以了，此时就不会报错了！我们看看为什么这样行，打开AbstractList中Iterator的remove实现方法：

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

可以看到它其实就是调用 List的remove方法，但是你再往后面看就会发现 expectedModCount=modCount,所以迭代器调用 next()的时候，判断的两个数值就相等了，就不会抛出异常了！那么我们要在遍历的时候，调用add(),set呢？很显然,在Iterator迭代器中没有这些方法，这时候我就需要通过 List.listIterator()去遍历，而不是还是通过 List.iterator遍历。好了，以上就是我分享的fast-fail，欢迎大家和我一起学习，一起讨论！