LinkedList 迭代器抛出并发修改异常

Question

有没有办法阻止 ListIterator 抛出 ConcurrentModificationException？这就是我想做的：

• 用一堆对象创建一个 LinkedList，这些对象有一个要经常执行的特定方法。
• 拥有一定数量的线程（比如N个），所有这些线程都负责执行LinkedList中对象的上述方法。例如，如果列表中有 k 个对象，线程 n 将执行列表中第 n 个对象的方法，然后继续执行第 n+N 个对象，然后执行第 n+2N 个等，直到它循环回到开头。

这里的问题在于这些对象的检索。我显然会使用 ListIterator 来完成这项工作。但是，我预测这不会走得太远，这要归功于根据文档将抛出的 ConcurrentModificationException。我希望列表是可修改的，并且迭代器不在乎。事实上，预计这些对象会创建和销毁列表中的其他对象。 我想到了一些解决方法：

• 创建和销毁一个新的迭代器以检索给定索引处的对象。但是，这是 O(n)，不可取。
• 请改用 ArrayedList；然而，这也是不可取的，因为删除是 O(n) 并且列表需要不时扩展（也许是收缩？）存在问题。
• 编写我自己的 LinkedList 类。不想。

因此，我的问题。有没有办法阻止 ListIterator 抛出 ConcurrentModificationException？

Answer 1

您似乎关心性能。您是否实际测量过使用 O(n) 与 O(1) 算法对性能的影响？根据您正在做什么以及您执行它的频率，简单地使用线程安全的CopyOnWriteArrayList 可能是可以接受的。它的迭代器也是线程安全的。

主要的性能拖累是可变操作（设置、添加、删除...）：每次都会重新创建一个新列表。

但是，对于大多数应用程序来说，性能已经足够好了。我个人会尝试使用它，分析我的应用程序以检查性能是否足够好，如果是就继续。如果不是，您将需要寻找其他方法。

Answer 2

有没有办法阻止 ListIterator 抛出 ConcurrentModificationException？

您以这种方式提出这个问题表明您对如何正确使用线程来提高应用程序的性能缺乏了解。

使用线程的全部目的是将处理和 IO 划分为独立的可运行实体，这些实体可以并行执行——相互独立。如果您将所有线程分叉以在同一个 LinkedList 上工作，那么您很可能会获得性能损失或最小增益，因为保持每个线程的“视图”所需的同步开销同步的LinkedList 将抵消并行执行带来的任何收益。

问题应该不是“我如何停止ConcurrentModificationException”，而应该是“我如何使用线程来改进对象列表的处理”。这是正确的问题。

要与多个线程并行处理对象集合，您应该使用ExecutorService 线程池。您可以使用类似于以下代码的内容创建池。 LinkedList（在本例中为 Job）中的每个条目将由池中的线程并行处理。

// create a thread pool with 10 workers
ExecutorService threadPool = Executors.newFixedThreadPool(10);
// submit each of the objects in the list to the pool
for (Job job : jobLinkedList) {
    threadPool.submit(new MyJobProcessor(job));
}
// once we have submitted all jobs to the thread pool, it should be shutdown
threadPool.shutdown();
// wait for the thread-pool jobs to finish
threadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
synchronized (jobLinkedList) {
    // not sure this is necessary but we need to a memory barrier somewhere
}
...
// you wouldn't need this if Job implemented Runnable
public class MyJobProcessor implements Runnable {
    private Job job;
    public MyJobProcessor(Job job) {
        this.job = job;
    }
    public void run() {
        // process the job
    }
}

Answer 3

您可以使用Iterator 来扫描列表，并使用Executor 通过传递到线程池来对每个对象执行工作。这很容易。以这种方式打包工作单元是有开销的。您仍然必须小心使用Iterator 方法来修改列表，但这可能会简化问题。

或者你可以一次完成你的工作，然后在下一次列出修改？

你能分成 N 个列表吗？

Answer 4

请看@assylias 的回答——他的建议很好。我要补充的是，如果您决定编写自己的链表类，则需要非常仔细地考虑如何使其成为线程安全的。

想一想如果多个线程同时尝试修改列表，您的列表可能会被破坏的所有方式。仅仅锁定 1 或 2 个节点是不够的——例如，以下面的列表为例：

A -> B -> C -> D

想象一个线程试图删除 B，就像另一个线程正在删除 C。要删除 B，从 A 的链接需要“跳过”B 到 C。但是如果 C 不再是列表的一部分怎么办？那时？同样，要删除 C，需要将来自 B 的链接更改为跳转到 D，但如果此时 B 已经从列表中删除了怎么办？当节点同时添加到列表的附近部分时，也会出现类似的问题。

如果每个节点有 1 个锁，并且在执行“删除”操作时锁定 3 个节点（要删除的节点，以及它之前和之后的节点），我认为这将是线程安全的。您还需要仔细考虑在添加节点以及遍历列表时必须锁定哪些节点。为了避免死锁，您需要确保始终以恒定的顺序获取锁，并且在遍历列表时，您需要使用“hand-over-hand”锁定（这排除了使用普通 Java 监视器 - 您需要显式锁定对象）。