java集合ArrayList和HashSet的fail-fast与fail-safe以及ConcurrentModificationException

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

fail-fast

ArrayList

public class TestList {

    public static void main(String[] args) {
        ArrayList 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 list = new ArrayList<>();
        list.add(1);
        list.add(3);
        list.add(2);

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

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

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

还可以使用 listIterator() 获取 ListIterator 来进行遍历删除，不会有异常。

HashSet

import java.util.HashSet;

public class TestSet {

    public static void main(String[] args) {
        HashSet 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 list = new HashSet<>();
        list.add(1);
        list.add(3);
        list.add(1);

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

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

    }
}

HashMap

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

通过以上分析得知，modCount 用于记录非遍历操作的。其实解决了变量修改同步的问题就可以了。

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

ArrayList 针对 removeIf() 进行了重写。

鉴于 java.utiil 里的集合类是线程不安全的，所以在 java.util.concurrent 中提供了可以在并发执行时线程安全的集合类。

fail-safe

CopyOnWriteArrayList

ArrayList 的线程安全实现。在修改操作执行时通过复制原始数组来实现，这样就造成了一个性能开销的问题。

总结

针对集合的元素移除问题最好还是获取其中的 iterator() 获取对应的迭代器来实现。

参考链接

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