并发修改异常发生在预期的时间

Question

有一个列表正在被两个线程同时排序和迭代。不出所料，它导致ConcurrentModificationException。不清楚的是错误的时间。

import java.util.stream.*;
import java.util.*;

public class Confusionist {
    static List<Integer> numbers;
    public static void main(String args[]) {
      numbers = IntStream.generate(() -> java.util.concurrent.ThreadLocalRandom.current().nextInt()).limit(100).boxed().collect(Collectors.toList());
      new Thread(new Accessor()).start();
      new Thread(new Accessor()).start();
    }
    
    static class Accessor implements Runnable{
        public void run(){
            String threadName = Thread.currentThread().getName();
            char threadDenoter = threadName.charAt(threadName.length()-1);
            System.out.printf("Thread: %s, Going to sort\n", threadName);
            Collections.sort(numbers, Integer::compareTo);
            Iterator<Integer> iterator = numbers.iterator();
            System.out.printf("Thread: %s, Going to iterate\n", threadName);
            while(iterator.hasNext()){
                iterator.next();
                System.out.printf("%c", threadDenoter);
            }
        }
    }
}

输出：（出现几次）

Thread: Thread-0, Going to sort
Thread: Thread-1, Going to sort
Thread: Thread-0, Going to iterate
0000000000000000000000000000000000000000000000000000000000000000000000000000000Exception in thread "Thread-0" java.util.ConcurrentModificationException
    at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:1013)
    at java.base/java.util.ArrayList$Itr.next(ArrayList.java:967)
    at HelloCodiva$Accessor.run(HelloCodiva.java:21)
    at java.base/java.lang.Thread.run(Thread.java:831)
000000Thread: Thread-1, Going to iterate
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
Completed with exit code: 0

1. 为什么当第一个线程完成时，另一个线程的迭代失败？
2. 当两个线程分别完成排序并获得迭代器时，底层迭代器将不会改变。为什么在此阶段会导致异常？

Answer 1

当两个线程分别完成排序并获得迭代器时，底层迭代器不会改变。为什么这会导致这个阶段的异常？

这种假设是不正确的，因为列表已经排序，第二次排序不会使迭代器无效。如果thread-1在thread-0初始化了迭代器之后对列表进行排序，则thread-0获取的迭代器将变得无效，并在访问时引发ConcurrentModificationException。

我可以想出一个操作序列来解释消息/错误。假设thread-0对列表进行了排序，创建了一个迭代器并打印了80个奇数，然后发生了上下文切换。线程-1将调用数组并打印100次。现在，当thread-0重新调度时，它的迭代器将不再有效，并抛出异常。

List<Integer> list =
        IntStream.generate(() -> java.util.concurrent.ThreadLocalRandom.current().nextInt(10))
            .limit(10)
            .boxed()
            .collect(Collectors.toList());
    Collections.sort(list, Integer::compareTo);
    Iterator<Integer> itr = list.iterator();
    Collections.sort(list, Integer::compareTo);

    while (itr.hasNext()) {
      System.out.println(itr.next());
    }

有趣的是，这只适用于list collectors.tolist（）返回类型。如果只是使用ArrayList我不会看到相同的行为。