fast-fail机制

来源：互联网发布：linux添加ip地址编辑：程序博客网时间：2024/06/05 06:11

什么是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);        }    }}

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

javac++

其实真实结果如下:

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>

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

   0Exception 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，欢迎大家和我一起学习，一起讨论！

0 0