有人可以通过ConcurrentModificationException向我解释吗？

Question

情况1：这不会引起ConcurrentModificationException？。谁能告诉我为什么这不会导致ConcurrentModificationException。

public class UpdatePeople {
    List < People > records = new ArrayList < People > ();

    public class AsyncTask extends AsyncTask < Void, Void, Boolean > {
        List < People > people;

        public AsyncTask(List < People > allergy) {
            this.people = people;
        }@
        Override
        protected Boolean doInBackground(Void...params) {
            List < String > responses = new ArrayList < String > ();
            for (People peopleList: this.people) {

            }

        }

    }
}

情况2：这ConcurrentModificationException是由于我尝试访问AsyncThread中的线程不安全的人员列表。我可以使我的“人员列表”实现CopyOnWriteArrayList是线程安全的，并且应该可以运行。

public class UpdatePeople {
        List < People > records = new ArrayList < People > ();

        public class AsyncTask extends AsyncTask < Void, Void, Boolean > {
            @
            Override
            protected Boolean doInBackground(Void...params) {
                List < String > responses = new ArrayList < String > ();
                for (People peopleList: records) {

                }

            }

        }
    }

1. 谁能解释我到底发生了什么case 1。我无法理解这是如何解决ConcurrentModificationException问题的。
2. 案例2是否将实现从更改ArrayList为CopyOnWriteArrayList推荐？

添加例外：

05-28 20：34：21.073：E / XXX（904）：未捕获的异常是：05-28 20：34：21.073：E /
XXX（904）：java.lang.RuntimeException：执行doInBackground（）时发生错误05-28
20：34：21.073：E / XXX（904）：在android.os.AsyncTask $
3.done（AsyncTask.java:299）05-28 20：34：21.073：E / XXX（904）：在Java
.util.concurrent.FutureTask $
Sync.innerSetException（FutureTask.java:273）05-28 20：34：21.073：E /
XXX（904）：at
java.util.concurrent.FutureTask.setException（FutureTask.java:124） 05-28
20：34：21.073：E / XXX（904）：位于java.util.concurrent.FutureTask $
Sync.innerRun（FutureTask.java:307）05-28 20：34：21.073：E / XXX（904）
：位于java.util.concurrent.FutureTask.run（FutureTask.java:137）05-28
20：34：21.073：E / XXX（904）：位于android.os.AsyncTask $ SerialExecutor $
1.run（AsyncTask.java： 230）05-28 20：34：21.073：E /
XXX（904）：位于java.util.concurrent。ThreadPoolExecutor.runWorker（ThreadPoolExecutor.java:1076）05-28
20：34：21.073：E / XXX（904）：at java.util.concurrent.ThreadPoolExecutor $
Worker.run（ThreadPoolExecutor.java:569）05-28 20： 34：21.073：E / XXX（904）：at
java.lang.Thread.run（Thread.java:856）05-28 20：34：21.073：E /
XXX（904）：原因：java.util.ConcurrentModificationException 05-28 20：34：21.073：E /
XXX（904）：at java.util.ArrayList $
ArrayListIterator.next（ArrayList.java:569）ArrayList $
ArrayListIterator.next（ArrayList.java:569）ArrayList $
ArrayListIterator.next（ArrayList.java:569）

Answer 1

一般来说ConcurrentModificationException，如果您尝试在迭代集合时修改集合，则会引发a。例如：

public class Main {

    public static void main(String[] args) 
    throws Exception {

        final List<Object> c1 = new ArrayList<Object>(Arrays.<Object>asList(1, 2, 3));
        for (Object o: c1) c1.remove(o);
    }
}

会java.util.ConcurrentModificationException在运行时导致运行，因为我们在迭代列表时正在修改列表（注意：此处仅涉及单个线程）。列表的迭代器检测到此情况，并导致异常。

如果所需修改是从迭代器刚收到非常元素的缺失，就可以达到预期的效果（在单线程情况下！）通过与工作直接迭代。将for（每个）循环替换为：

final Iterator<Object> iterator = c1.iterator();

while (iterator.hasNext()) {

    final Object o = iterator.next();
    if (satisfiesSomeCriterion(o)) iterator.remove();
}

但是，这并不适用于所有修改。例如，添加将不起作用。以下代码仍然失败：

for (Object o: c1) c1.add(Integer.valueOf(((Integer)o).intValue() + 10));

如果基础集合是List，则可以使用a ListIterator代替普通的迭代器来解决此限制：

final ListIterator<Integer> iterator = c1.listIterator();

while (iterator.hasNext()) {

    final Integer o = iterator.next();
    if (satisfiesSomeCriterion(o)) iterator.add(Integer.valueOf(o.intValue() + 10);
}

但是请注意，这与上面给出的代码（插入元素的其他位置）不同。还要注意，这ListIterator.add是一个可选方法；一个实现可能UnsupportedOperationException在调用时抛出一个。

上述所有内容仅适用于单线程情况。如果您尝试在没有适当同步的情况下从多个线程同时访问同一集合，则会出现一系列新问题，因为这不仅可能导致ConcurrentModificationException迭代线程中出现s，而且可能破坏集合内部数据的完整性。结构。

您可以做几件事：

• 使用并发感知集合（例如CopyOnWriteArrayList您已经提到的集合）
• 通过Collections.synchronizedList（...Set，...Whatever）包装集合。但是请注意，在这种情况下，您仍然有责任针对迭代提供适当的锁定规则。有关详细信息，请参见此答案。
• 在将原始集合传递给后台作业之前，先对其进行备份（并确保后台作业是使用该副本的唯一线程）
• 通过synchronized块保护集合的所有使用（例如，将集合本身​​用作“监视”对象，尽管更好：使用专用的监视对象）。