java的fail-fast与fail-safe以及ConcurrentModificationException

在 java 的集合工具类中，例如对?ArrayList 或者 HashSet 进行删除元素后再遍历元素时，会抛出?ConcurrentModificationException 异常。

fail-fast

ArrayList

public class TestList {

    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(3);
        list.add(2);

        for (Integer num:list) {
            if(num==1){
                list.remove(num);
            }
        }

    }
}

执行完代码之后报错?ConcurrentModificationException

Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:911)
	at java.util.ArrayList$Itr.next(ArrayList.java:861)

接下来看看怎么回事

看一下编译后的字节码

javap -verbose TestList

将字节码反编译后可以看到 foreach 循环最终通过调用?ArrayList#iterator() 获取 Iterator 实现循环处理的。

通过源码可以发现，iterator() 返回的是一个实现了接口?Iterator 的内部类 Itr，通过其中的方法来实现遍历操作。

然而报错的原因是因为?modCount != expectedModCount

在上面的代码中可以看到，在循环遍历的时候会生成一个 Itr 类，将?modCount 赋值给?expectedModCount，然而?modCount 在?AbstractList 中定义。通过注释得知，modCount 用于进行?fail-fast 处理，针对子类可以针对此变量值进行修改。

在调用?ArrayList#add() 时，会针对?modCount 进行累加操作。

在调用?ArrayList#remove() 时，同样会进行累加操作。

在循环遍历的过程中，如果调用了?remove()，会调用?ArrayList#remove() 进行元素删除，继续遍历会执行?Iterator 的 hasNext() 和 next() 来遍历移除元素后的数据。但是这里的?remove() 没有调用内部类 Itr 的?remove()，所以在执行 next() 中调用?checkForComodification() 时两个变量值不一致，抛出了异常。

但是在?Itr#remove() 中会将?modCount 给?expectedModCount 赋值，所以，不会有值不一致的情况。

接下来修改代码如下

import java.util.ArrayList;
import java.util.Iterator;

public class TestList {

    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(3);
        list.add(2);

        /*for (Integer num:list) {
            if(num==1){
                list.remove(num);
            }
        }*/

        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            Integer num = iterator.next();
            if(num==1){
                iterator.remove();
            }
        }
    }
}

这样的话使用了内部类?Itr#remove() 进行移除，没有异常。

HashSet

import java.util.HashSet;

public class TestSet {

    public static void main(String[] args) {
        HashSet<Integer> list = new HashSet<>();
        list.add(1);
        list.add(3);
        list.add(2);

        for (Integer num:list) {
            if(num==1){
                list.remove(num);
            }
        }

    }
}

Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.HashMap$HashIterator.nextNode(HashMap.java:1445)
	at java.util.HashMap$KeyIterator.next(HashMap.java:1469)

在进行 add() 操作时，调用了?HashMap#put() 进行赋值，其中 key 为 add() 的数据，value 是一个?Object 对象。

调用 remove() 时调用?HashMap#remove() 与?Object 判断。

可以看到 HashSet 内部使用的?HashMap 来确保了数据的唯一性。其中 HashMap 在 put() 时将 key 进行哈希运算，将得到的哈希值与数组下标进行按位与运算取得对应的数组下标（HashMap 通过数组+链表的方式解决哈希冲突的问题），如果有相同的哈希值数据会进行覆盖（在进行 put() 时会将当前 key 值与链表中的值进行 equals 比对，如果相同进行覆盖），否则添加新节点。

针对?HashSet 的问题，与?ArrayList 类似，只是内部使用了?HashMap 的 keySet 的迭代器，但是这个迭代器只创建一次，ArrayList 每次都创建一个。

调用?HashMap 的?keySet()

调用?HashMap 内部类?KeyIterator 的 next()，间接调用父类 HashIterator#nextNode()。

类似于?ArrayList，在创建?KeySet 对象时将?modCount 赋值给?expectedModCount。

在调用?HashSet 的?remove() 最终会调用?HashMap#removeNode()，执行过程中会对?modCount 进行累加。

下次进行遍历时在 nextNode() 中进行两个变量值比较，鉴于值不同，所以报错。

但是在?HashIterator#remove() 中会将?modCount 给?expectedModCount 赋值，所以，不会有值不一致的情况。

修改后的代码如下

import java.util.HashSet;
import java.util.Iterator;

public class TestSet {

    public static void main(String[] args) {
        HashSet<Integer> list = new HashSet<>();
        list.add(1);
        list.add(3);
        list.add(1);

        /*for (Integer num:list) {
            if(num==1){
                list.remove(num);
            }
        }*/

        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            Integer num = iterator.next();
            if(num==1){
                iterator.remove();
            }
        }

    }
}

HashMap

没有这个问题，因为在移除元素的逻辑中没有与?modCount 比较的逻辑。

在 jdk 8 中?Collection 新增了?removeIf() 来删除符合要求的元素，通过?Iterator 来实现，可以避开 remove() 调用带来的问题。

参考链接

https://stackoverflow.com/questions/17377407/what-are-fail-safe-fail-fast-iterators-in-java

https://blog.csdn.net/chenssy/article/details/38151189

https://zhuanlan.zhihu.com/p/37476508

https://blog.csdn.net/weixin_50799082/article/details/131628138

https://blog.csdn.net/lovezhaohaimig/article/details/80494731