并发修改异常

Question

我有一小段代码，它给了我并发修改异常。我无法理解为什么我不断收到它，即使我没有看到任何并发修改正在进行。

import java.util.*;

public class SomeClass {
    public static void main(String[] args) {
        List<String> s = new ArrayList<>();
        ListIterator<String> it = s.listIterator();

        for (String a : args)
            s.add(a);

        if (it.hasNext())
            String item = it.next();

        System.out.println(s);
    }
}

Answer 1

为了避免 ConcurrentModificationException，您应该这样编写代码：

import java.util.*;

public class SomeClass {

    public static void main(String[] args) {
        List<String> s = new ArrayList<String>();

        for(String a : args)
            s.add(a);

        ListIterator<String> it = s.listIterator();    
        if(it.hasNext()) {  
            String item = it.next();   
        }  

        System.out.println(s);

    }
}

java.util.ListIterator 允许您在迭代期间修改列表，但不能在创建列表和使用列表之间修改列表。

Answer 2

我无法理解为什么我不断收到它，即使我没有看到任何并发修改正在进行。

在创建迭代器和开始使用迭代器之间，您向要迭代的列表添加了参数。这是并发修改。

    ListIterator<String> it = s.listIterator();  

    for (String a : args)
        s.add(a);                    // concurrent modification here

    if (it.hasNext())
        String item = it.next();     // exception thrown here

将元素添加到列表后创建迭代器：

    for (String a : args)
        s.add(a); 

    ListIterator<String> it = s.listIterator();  
    if (it.hasNext())
        String item = it.next();

Answer 3

来自 ConcurrentModificatoinException 的 JavaDoc:： “通常不允许一个线程修改集合，而另一个线程正在迭代它”。

它只是意味着，如果您仍然有一个打开的迭代器，则不允许您修改列表，因为迭代器循环将中断。尝试移动 ListIterator; it = s.listIterator(); 直到 for 循环之后。

Answer 4

修改基础列表后，您不能继续迭代迭代器。在这里，您在向 s 添加一些项目之前创建迭代器，然后继续对其执行 hasNext() 和 next()添加后，导致 ConcurrentModificationException

Answer 5

如果上述解决方案不能正常工作。您可以使用旧的 for 循环来迭代列表，同时添加新项目。 请参阅下面的示例：

import java.util.*;

public class SomeClass {
    public static void main(String[] args) {
        ArrayList<AClass> aList = new ArrayList<AClass>(); // we will iterate this


        // this will cause ConcurrentModificationException. 
        // Since we are iterating the list, at the same time modifying it.
        /*for(AClass a: aList){
           aList.add(someMethod(a));
        }*/

        // old fashion for-loop will help
        int limit = aList.size();
        for(int i=0; ctr<limit; ++i){
           AClass a = aList.get(i);
           aList.add(someMethod(a));
        }


    }
}

Answer 6

要理解这一点，让我们看一下 HashMap 实现的源代码：

public class HashMap<K, V> extends AbstractMap<K, V> implements Cloneable, Serializable{

其中包含 HashIterator，如下所示：

private abstract class HashIterator {
    ...
    int expectedModCount = modCount;
    ...

    HashMapEntry<K, V> nextEntry() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        .... 
        }

每次创建迭代器时：

• 都会创建一个计数器 expectedModCount 并将其设置为 modCount 的值 入口检查点
• 当使用 put/get（添加/删除）时，
• modCount 会递增nextEntry 迭代器的方法会使用当前 modCount 检查此值（如果它们不同），则抛出并发修改异常

以避免您可以：

• 将映射转换为数组（不建议用于大型映射）
• 使用并发映射或列表类（CopyOnWriteArrayList / ConcurrentMap）
• 锁定映射（这种方法消除了多线程的好处）

这将允许您同时迭代并添加或删除元素，而不会引发异常

并发映射/列表迭代器是一个“弱一致”迭代器，它将
永远不会抛出 ConcurrentModificationException，并保证
遍历构建迭代器时存在的元素，
并且可能（但不保证）反映任何修改
施工后。

有关 CopyOnWriteArrayList 的详细信息

Answer 7

ConcurrentModificationException在单线程环境和多线程环境中都可能出现。
主要问题是所有通用迭代器（如 ArrayList 中使用的迭代器）都是 FailFast 迭代器，当我们尝试修改一个列表（如果一个迭代器已经在迭代该列表）时，该迭代器会失败。
解决方案->如果需求需要这种情况，请使用 CopyOnWriteArrayList 而不是使用 ArrayList。

对于完整的演示，可以使用下面提到的代码。
我们只需要将实现从 CopyOnWriteArrayList 更改为 ArrayList 即可。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * @author narif
 *
 */
public class TestApp {

    /**
     * @param args
     */
    public static void main(String[] args) {
        List<String> testList = new ArrayList<>();
        testList.add("abc");
        testList.add("abc");
        testList.add("abc");
        testList.add("abc");
        testList.add("abc");
        testList.add("abc");
        testList.add("abc");
        testList.add("abc");
        testList.add("abc");
        testList.add("abc");
        testList.add("abc");
        testList.add("abc");
        testList.add(6, "abcAtindex6");
        int size = testList.size();
        System.out.println("The Current List (ArrayList) is: " + testList);
        System.out.println("The size of the List (ArrayList) is: " + size);
        /* Comment the below lines to get the ConcurrentModificationException */
        testList = new CopyOnWriteArrayList<>(testList);
        for (String value : testList) {
            System.out.println("The Value from ForEach Loop is: " + value);
            /*
             * Concurrent modification is happening here
             * One iterator is iterating over the list while we are trying to add new values to
             * the list so the results of the iteration are undefined under these circumstances.
             * So teh fail fast iterators will fail and will throw the ConcurrentModificationException.
             */
            testList.add("valueFromForLoop");
            testList.add("anotherValueFromForEachLoop");
        }
        Iterator<String> it = testList.iterator();
        while (it.hasNext()) {
            String abc = it.next();
            System.out.println(abc);
            testList.add("Value from Iterator1");
            testList.add("Value from Iterator2");
            testList.add("Value from Iterator3");
            testList.add("Value from Iterator4");

        }
        System.out.println("Did the modificationa and all after conevrting the ArrayList to CopyOnWriteArrayList.");
        System.out.println("Calling the method to get the new List..");
        testList = new CopyOnWriteArrayList<>(getTheList(testList));
        for (String value : testList) {
            System.out.println("The value returned from method is : " + value);
        }
    }

    private static List<String> getTheList(List<String> pList) {
        List<String> list = new CopyOnWriteArrayList<>(pList);
        int i = 0;
        for (String lValue : list) {
            System.out.println("The list Passed is " + list);
            i++;
            list.add("localVaueFromMethod" + i);
            list.removeAll(pList);
        }
        return list;
    }

}

有关更多信息，请点击此链接，这可能会很有帮助 ConcurrentModificationException Java 文档

Answer 8

这不起作用：

LinkedList<String> linkedList = new LinkedList<String>();
ListIterator listIterator = linkedList.listIterator();
linkedList.add("aa");
linkedList.add("bb");

这起作用了：

LinkedList<String> linkedList = new LinkedList<String>();
linkedList.add("aa");
linkedList.add("bb");
ListIterator listIterator = linkedList.listIterator();

Answer 9

查看 oracle 文档 页面。

public class ConcurrentModificationException
extends RuntimeException

当不允许修改对象时，检测到并发修改的方法可能会抛出此异常

请注意，此异常并不总是表明对象已被不同的线程同时修改。如果单个线程发出一系列违反对象约定的方法调用，则该对象可能会抛出此异常。 例如，如果线程在使用快速失败迭代器迭代集合时直接修改集合，则迭代器将抛出此异常。

就您而言，您在创建迭代器后修改了集合，因此遇到了异常。

如果您按照 Stephen C 答案更改代码，你不会得到这个错误。