Java 为什么这段代码不抛出ConcurrentModificationException？

我试图理解为什么我的一些代码没有抛出ConcurrentModificationException。我正在循环一个集合中的元素，然后向集合中添加更多元素，但我预期会出现异常

问题：给定一个有向树，如果两个给定节点有一个共同的祖先，则返回true。注意：这不是一棵有根的树（即一棵有根的树）。我们得到的边对是（父、子）。节点具有唯一的ID

import java.io.*;
import java.util.*;


class Solution {
  public static void main(String[] args) {
    int[][] pairs = {{11,6},{9,6},{9,8},{10,8}, {6,2},{5,2},{5,1},{8,3},{8,4}};

    System.out.println(hasCommonAncestor(pairs, 3,4));
    System.out.println(hasCommonAncestor(pairs, 2,4));    
    System.out.println(hasCommonAncestor(pairs, 1,3));
    System.out.println(hasCommonAncestor(pairs, 6,8));    

  }


  private static boolean hasCommonAncestor(int[][] pairs, int a, int b) {
    Map<Integer, Set<Integer>> firstLevelParents = new HashMap<>();

    for(int[] pair : pairs) {
      int parent = pair[0];
      int child = pair[1];
      Set<Integer> parents = firstLevelParents.getOrDefault(child, new HashSet<>());
      parents.add(parent);
      firstLevelParents.put(child, parents);
    }


    Set<Integer> aParents = firstLevelParents.get(a);
    Set<Integer> bParents = firstLevelParents.get(b);

    for(Integer parent : aParents) {
      Set<Integer> parentsParents = firstLevelParents.getOrDefault(parent, new HashSet<>());
      aParents.addAll(parentsParents);
    }

    for(Integer parent : bParents) {
      Set<Integer> parentsParents = firstLevelParents.getOrDefault(parent, new HashSet<>());
      bParents.addAll(parentsParents);
    }


    return aParents.removeAll(bParents);
  }
}

import java.io.*；
导入java.util.*；
类解决方案{
公共静态void main（字符串[]args）{
int[][]对={{11,6}，{9,6}，{9,8}，{10,8}，{6,2}，{5,2}，{5,1}，{8,3}，{8,4}；
System.out.println（hasCommon祖先（对，3,4））；
System.out.println（hasCommon祖先（成对，2,4））；
System.out.println（hasCommon祖先（成对，1,3））；
系统输出println（hasCommonAsentor（pairs，6,8））；
}
私有静态布尔hasCommon祖先（int[][]对，int a，int b）{
Map firstLevelParents=newhashmap（）；
for（int[]对：对）{
int parent=pair[0]；
int child=pair[1]；
Set parents=firstLevelParents.getOrDefault（child，new HashSet（））；
parents.add（parent）；
一级家长。放置（孩子、家长）；
}
Set aParents=firstLevelParents.get（a）；
设置bParents=firstLevelParents.get（b）；
对于（整数父项：aParents）{
Set parentsParents=firstLevelParents.getOrDefault（parent，new HashSet（））；
aParents.addAll（家长）；
}
对于（整数父级：bParents）{
Set parentsParents=firstLevelParents.getOrDefault（parent，new HashSet（））；
b家长。添加所有（家长）；
}
返回aParents.removeAll（b家长）；
}
}

在某些输入下，此代码仍可能抛出

ConcurrentModificationException

。从Javadoc获取异常：

请注意，fail fast行为无法得到保证，因为一般来说，在存在非同步并发修改的情况下，不可能做出任何硬保证。快速失败的操作会尽最大努力抛出ConcurrentModificationException。因此，编写依赖于此异常的正确性的程序是错误的：ConcurrentModificationException应该只用于检测bug

例如，此代码工作正常：

public final class Main {

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

        for (Integer n : numbers) {
            numbers.add(n + 1);
        }

        System.out.println(numbers); // [1, 2, 3, 4]
    }
}

换句话说，代码的某些路径可能导致

ConcurrentModificationException

，但其他路径可能不会，您不应该依赖此结果

public final class Main {

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

        for (Integer n : numbers) {
            // Changed 1 to a 10.
            numbers.add(n + 10);
        }

        System.out.println(numbers);
    }
}