为什么 it.next() 会抛出 java.util.ConcurrentModificationException？

Question

final Multimap<Term, BooleanClause> terms = getTerms(bq);
        for (Term t : terms.keySet()) {
            Collection<BooleanClause> C = new HashSet(terms.get(t));
            if (!C.isEmpty()) {
                for (Iterator<BooleanClause> it = C.iterator(); it.hasNext();) {
                    BooleanClause c = it.next();
                    if(c.isSomething()) C.remove(c);
                }
            }
        }

不是 SSCCE，但你能闻到气味吗？

Answer 1

HashSet 类的 Iterator 是一个快速失败迭代器。来自 HashSet 类：

此类的迭代器方法返回的迭代器是快速失败的：
如果在创建迭代器后随时修改集合，则
除了通过迭代器自己的删除方法之外的任何方式，迭代器
抛出 ConcurrentModificationException。于是，面对
并发修改，迭代器快速而干净地失败，
而不是冒着任意、非确定性行为的风险
未来的时间不确定。

请注意，无法保证迭代器的快速失败行为
因为一般来说，不可能做出任何硬性保证
存在不同步的并发修改。快速失败
迭代器尽力抛出 ConcurrentModificationException
基础。因此，编写依赖于
关于此异常的正确性：快速失败行为
迭代器应该仅用于检测错误。

请注意最后一句 - 您捕获 ConcurrentModificationException 的事实意味着另一个线程正在修改集合。同一个 Javadoc API 页面还指出：

如果多个线程同时访问一个哈希集，并且至少一个
线程修改集合，它必须在外部同步。
这通常是通过同步某个对象来完成的
自然地封装了集合。如果不存在这样的对象，则设置
应该使用 Collections.synchronizedSet 方法。这
最好在创建时完成，以防止意外不同步
访问该集：

Set s = Collections.synchronizedSet(new HashSet(...));

我相信对 Javadoc 的引用对于下一步应该做什么是不言自明的。

此外，就您而言，我不明白您为什么不使用 ImmutableSet，而不是在 terms 对象上创建 HashSet（可能会在此期间进行修改；我看不到 getTerms 方法的实现，但我有预感底层键集正在被修改）。创建不可变集将允许当前线程拥有原始键集的自己的防御副本。

请注意，虽然可以通过使用同步集来防止 ConcurrentModificationException（如 Java API 文档中所述），但前提条件是所有线程都必须访问同步集合而不是直接访问后备集合（在您的情况下可能不正确，因为 HashSet 可能是在一个线程中创建的，而 MultiMap 的底层集合是由其他线程修改的）。同步集合类实际上维护一个内部互斥锁，供线程获取访问权限；由于您无法直接从其他线程访问互斥体（在这里这样做是非常荒谬的），因此您应该考虑使用键集或 MultiMap 本身的防御性副本 使用 MultiMaps 类 的 unmodifyingMultimap 方法（您需要从 getTerms 方法返回一个不可修改的 MultiMap）。您还可以调查返回 同步 MultiMap，但话又说回来，您需要确保互斥锁必须由任何线程来保护底层集合免受并发修改。

请注意，我故意省略了使用 线程安全 HashSet 的唯一原因是我不确定是否能确保对实际集合的并发访问；但情况很可能并非如此。

---

编辑：在单线程场景中 Iterator.next 上抛出 ConcurrentModificationException

这是关于语句： if(c .isSomething()) C.remove(c); 这是在编辑的问题中引入的。

调用 Collection.remove 会改变问题的性质，因为现在即使在单线程场景中也可能抛出 ConcurrentModificationException 。

这种可能性是由于方法本身的使用以及Collection的迭代器的使用而产生的，在本例中是使用语句初始化的变量it : 迭代器它 = C.iterator();。

遍历 Collection C 的 Iterator it 存储与 Collection< 的当前状态相关的状态/代码>。在这种特殊情况下（假设是 Sun/Oracle JRE），KeyIterator（HashMap 类的内部内部类，由 HashSet 使用） >) 用于迭代Collection。此 Iterator 的一个特殊特征是，它通过它的 Collection（在本例中为 HashMap）跟踪对 Collection 执行的结构修改的数量。 code>Iterator.remove 方法。

当您直接在 Collection 上调用 remove，然后调用 Iterator.next 时，迭代器会抛出一个 ConcurrentModificationException，因为 Iterator.next 验证是否发生了 Iterator 不知道的任何 Collection 结构修改。在这种情况下，Collection.remove 会导致结构修改，该修改由 Collection 跟踪，但不由 Iterator 跟踪。

要解决这部分问题，您必须调用 Iterator.remove 而不是 Collection.remove，因为这可确保 Iterator 现在可以识别对 Collection 的修改。在这种情况下，Iterator 将跟踪通过 remove 方法发生的结构修改。因此，您的代码应如下所示：

final Multimap<Term, BooleanClause> terms = getTerms(bq);
        for (Term t : terms.keySet()) {
            Collection<BooleanClause> C = new HashSet(terms.get(t));
            if (!C.isEmpty()) {
                for (Iterator<BooleanClause> it = C.iterator(); it.hasNext();) {
                    BooleanClause c = it.next();
                    if(c.isSomething()) it.remove(); // <-- invoke remove on the Iterator. Removes the element returned by it.next.
                }
            }
        }

Answer 2

原因是您正在尝试修改迭代器外部的集合。

它是如何工作的：

当您创建迭代器时，集合会独立地为集合和迭代器维护一个modificationNum变量。
1. 对于集合和迭代器所做的每次更改，集合变量都会递增。
2. 每次对迭代器进行更改时，迭代器的变量都会递增。

因此，当您通过迭代器调用 it.remove() 时，修改的值都会增加-number-variable 减 1。

但是，当您直接对集合调用collection.remove() 时，只会增加集合的modification-numbervariable 的值，而不增加迭代器的变量。

规则是：只要迭代器的修改号值与原始集合修改号值不匹配，就会给出 ConcurrentModificationException。

Answer 3

Vineet Reynolds 详细解释了集合抛出 ConcurrentModificationException 的原因（线程安全、并发）。 Swagatika 非常详细地解释了该机制的实现细节（集合和迭代器如何统计修改次数）。

他们的回答很有趣，我给他们投了赞成票。但是，就您而言，问题并非来自并发（您只有一个线程），并且实现细节虽然有趣，但不应在此考虑。

您应该只考虑 HashSet javadoc 的这一部分：

此类的迭代器方法返回的迭代器是快速失败的：
如果在创建迭代器后随时修改集合，则
除了通过迭代器自己的删除方法之外的任何方式，迭代器
抛出 ConcurrentModificationException。于是，面对
并发修改，迭代器快速而干净地失败，
而不是冒着任意、非确定性行为的风险
未来的时间不确定。

在代码中，您使用 HashSet 的迭代器对其进行迭代，但使用 HashSet 自己的删除方法来删除元素 ( C.remove(c) )，这会导致 ConcurrentModificationException。相反，如 javadoc 中所述，您应该使用 Iterator 自己的remove() 方法，该方法从底层集合中删除当前正在迭代的元素。

替换

                if(c.isSomething()) C.remove(c);

为

                if(c.isSomething()) it.remove();

如果您想使用更实用的方法，您可以创建一个 谓词并使用Guava的Iterables.removeIf() 方法：

Predicate<BooleanClause> ignoredBooleanClausePredicate = ...;
Multimap<Term, BooleanClause> terms = getTerms(bq);
for (Term term : terms.keySet()) {
    Collection<BooleanClause> booleanClauses = Sets.newHashSet(terms.get(term));
    Iterables.removeIf(booleanClauses, ignoredBooleanClausePredicate);
}

PS：请注意，在在这种情况下，这只会从临时 HashSet 中删除元素。 Multimap 不会被修改。