What are the common causes of ConcurrentModificationException in Java?

What are the common causes of ConcurrentModificationException in Java?

When using the iterator in the Java collection framework to traverse a collection, a ConcurrentModificationException exception is sometimes thrown. This is one of the common Java exceptions. So, what is the reason for this exception?

First of all, we need to understand that the iterators provided by the Java collection framework are stateful. In other words, during traversal, changes in the state may cause exceptions to be thrown.

The following are the causes of common ConcurrentModificationException exceptions:

1. When iterating a collection, if its structure is modified (such as adding or deleting elements), a ConcurrentModificationException exception will be thrown.

For example, when we directly modify the content of an ArrayList using a foreach iterator, such as adding or deleting elements, a ConcurrentModificationException will be thrown.

List<String> list = new ArrayList<>();
list.add("Java");
list.add("C++");
list.add("Python");

for(String s : list){
    if(s.equals("Java")){
        list.remove(s); //这句会抛出ConcurrentModificationException异常
    }
}

2. When iterating a collection, if its structure is modified, different iterators may throw ConcurrentModificationException exceptions.

For example, when we use an Iterator to traverse an ArrayList and use another thread to add or delete elements, a ConcurrentModificationException will be thrown.

List<String> list = new ArrayList<>();
list.add("Java");
list.add("C++");
list.add("Python");

Iterator<String> iterator = list.iterator();

while(iterator.hasNext()){
    String s = iterator.next();
    if(s.equals("Java")){
        list.remove(s); //在另一个线程中添加或删除元素，就会抛出ConcurrentModificationException异常
    }
}

3. When iterating a collection, if its structure is modified, different iterators may exhibit different behaviors.

For example, we add or delete elements during the iterator traversal of ArrayList, which reduces the performance and expectations of ArrayList during traversal operations. What's more, Iterator may enter an infinite loop or throw ConcurrentModificationException.

List<String> list = new ArrayList<>();
list.add("Java");
list.add("C++");
list.add("Python");

Iterator<String> iterator1 = list.iterator();
Iterator<String> iterator2 = list.iterator();

while(iterator1.hasNext()){
    String s = iterator1.next();
    if(s.equals("Java")){
        list.remove(s); //会抛出ConcurrentModificationException异常
    }
    while(iterator2.hasNext()){
        // 进入无限循环
    }
}

To summarize:

The iterator provided by the Java collection framework is stateful. When the iterator traverses the collection, it will record its current state, including the location of the traversed elements and other information. . When the structure is modified during the traversal process, ConcurrentModificationException will be thrown.

Therefore, when traversing a collection, be sure not to modify its content directly within the loop body, otherwise an exception will be thrown. If you need to modify it, you can use the Iterator's remove() method to delete it. If multiple threads modify the collection concurrently, be careful to avoid throwing ConcurrentModificationException.

The above is the detailed content of What are the common causes of ConcurrentModificationException in Java?. For more information, please follow other related articles on the PHP Chinese website!