ConcurrentModificationException in Java

Last Updated : 30 Jan 2026

ConcurrentModificationException in Java is an exception that tells us that the collection is modified structurally while any of its elements are being traversed concurrently. This generally occurs when the collection is changed during an iteration of an iterator (for example, adding or removing elements).

Let's delve into this in more detail:

1. Concurrency and Iteration

In Java, collections may be modified concurrently so that one thread is modifying the collection while another is traversing it. Yet, the Java Collections Framework, by default, is not inherently thread-safe. By that, it means if you try to modify a collection while another thread is iterating over it, you will encounter such kind of problems as ConcurrentModificationException.

2. Cause of ConcurrentModificationException

The most usual case of ConcurrentModificationException occurs when one uses an iterator (e.g., Iterator, ListIterator) to iterate over a collection while modifying the collection (i.e., adding/removing elements) outside the iterator context. The iterator takes care of the internal structure of the collection. It throws a ConcurrentModificationException if it detects that the structure has been changed outside of itself, which implies that the current iteration is not valid.

Example of ConcurrentModificationException

Note: It is not mandatory that this exception will be thrown only when some other thread tries to modify a Collection object. It can also happen if a single thread has some methods called which are trying to violate the contract of the object. It may happen when a thread is trying to modify the Collection object while it is being iterated by some fail-fast iterator; the iterator will throw the exception.

Example

import java.awt.List;
import java.util.*;

public class Concurrentmodificationexception {

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

		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
		list.add(5);

		Iterator<Integer> it = list.iterator();
		while (it.hasNext()) {                 
Integer value = it.next();            
			System.out.println("List Value:" + value);
			if (value.equals(3))
				list.remove(value);
		}

	}

}

Output:

This message says that the exception is thrown when the next method is called as the iterator is iterating the list and we are making modifications in it simultaneously. But if we make modifications in hashmap like given below, then it will not throw any such exception as the size of the hashmap won't change.

For Example-

import java.awt.List;
import java.util.*;

public class concurrentmodificationexception {

	public static void main(String[] args) {
		
		HashMap<Integer, Integer> map = new HashMap<>();
		map.put(1, 1);
		map.put(2, 2);
		map.put(3,3);
		
		Iterator<Integer> it = map.keySet().iterator();
		while(it.hasNext()) {
			Integer key = it.next();
			System.out.println("Map Value:" + map.get(key));
			if (key.equals(2)) {
				map.put(1, 4);
			}
		}	
	}
}

Output:

Map Value:1
Map Value:2
Map Value:3

This example works completely fine as while the iterator is iterating over the map, the size of the map is not changing. Only the map is being updated in the if statement.

Constructors of ConcurrentModificationException

There are 4 types of constructors of ConcurrentModificationException -

public ConcurrentModificationException()-
It creates a ConcurrentModificationException with no parameters.
public ConcurrentModificationException(String message)
It creates a ConcurrentModificationException with a detailed message specifying the Exception.
public ConcurrentModificationException(Throwable cause)
It creates a ConcurrentModificationException with a cause and a message which is (cause==null?null:cause.toString()). The cause is later retrieved by the Throwable.getCause().
public ConcurrentModificationException(String message, Throwable cause)
It creates a ConcurrentModificationException with a detailed message and a cause. (cause==null?null:cause.toString()). The message is later retrieved by Throwable.getMessage() and cause is later retrieved by Throwable.getCause().

How to avoid ConcurrentModificationException in a multi-threaded environment?

To avoid ConcurrentModificationException in a multiprogramming environment, we need to employ techniques to synchronize the access to those shared collections or use thread-safe data structures. Here are some techniques to accomplish this:

1. Use Thread-Safe Collections:

Java has several thread-safe collection classes in the java.util.concurrent packages like ConcurrentHashMap, CopyOnWriteArrayList, ConcurrentLinkedQueue, etc which are created to be used safely in a multi-threading environment without doing external synchronization.

Example:

ConcurrentHashMap<KeyType, ValueType> concurrentMap = new ConcurrentHashMap<>();

2. Synchronize Access:

If you are using the regular collections (for example, ArrayList, HashMap, etc.), synchronization of their access has to be done manually using explicit blocking/synchronization (for example, using synchronized keyword or ReadWriteLock).

Example:

List<String> synchronizedList = Collections.synchronizedList(new ArrayList<>());

3. Iterator's remove() method:

While iterating through the collection, use the iterator's remove() method instead of modifying directly on the collection. This ensures that all adjustments are made safely through the iterator.

Example

List<String> list = new ArrayList<>();
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    if (condition) {
        iterator.remove(); // Safe removal using iterator
    }
}

4. Copy the Collection:

If the size of the collection is small and iterations over it are made from time to time, you should consider making a copy of it before modifying it. Hence, you can refactor the copy safely without checking for concurrent modifications.

5. Use Immutable Collections:

If the collection is necessary to avoid modification after creation, consider immutable collections from libraries like Google Guava or Java 9+ List.of(), Set.of(), etc. Immutable collections can be safely shared among threads without synchronization.

Example :

6. Atomic Operations:

For specialized instances, you can use atomic operations, which are offered by classes like AtomicInteger, AtomicLong, etc., to achieve thread safe modification.

Example:

AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet(); // Atomic increment

7. Proper Thread Synchronization:

Proper thread synchronization can avoid concurrent modification issues. Synchronization constructs such as synchronized blocks, Lock objects, etc., can be employed to control access to shared data.

ConcurrentModificationExample.java

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
public class ConcurrentModificationExample {
    public static void main(String[] args) {
        // Create a thread-safe list
        List<String> list = new CopyOnWriteArrayList<>();
        // Create and start multiple threads
        Thread writerThread = new Thread(new Writer(list));
        Thread readerThread = new Thread(new Reader(list));
        writerThread.start();
        readerThread.start();
    }
    static class Writer implements Runnable {
        private final List<String> list;
        Writer(List<String> list) {
            this.list = list;
        }
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                // Add elements to the list
                list.add("Element " + i);
                System.out.println("Added: Element " + i);
                try {
                    Thread.sleep(1000); // Simulate some processing time
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    static class Reader implements Runnable {
        private final List<String> list;
        Reader(List<String> list) {
            this.list = list;
        }
        @Override
        public void run() {
            // Read elements from the list
            for (String element : list) {
                System.out.println("Read: " + element);
                try {
                    Thread.sleep(500); // Simulate some processing time
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Output:

Added: Element 0
Added: Element 1
Added: Element 2
Added: Element 3
Added: Element 4

4.2 How to avoid ConcurrentModificationException in a single-threaded environment?

In a single-threaded environment, you typically don't face the same concurrency issues as in a multi-threaded environment. However, you might still encounter ConcurrentModificationException if you attempt to modify a collection while iterating over it. Here's how you can avoid it in a single-threaded context:

1. Use Iterator's remove() Method:

List<String> list = new ArrayList<>();
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    if (condition) {
        iterator.remove(); // Safe removal using iterator
    }
}

2. Use for-each Loop:

In Java 5 and later, you can use the enhanced for loop, which internally uses an iterator and allows the safe removal of elements:

List<String> list = new ArrayList<>();
for (Iterator<String> iterator = list.iterator(); iterator.hasNext();) {
    String element = iterator.next();
    if (condition) {
        iterator.remove(); // Safe removal using iterator
    }
}

3. Use ListIterator:

If you need to traverse the list bidirectionally and modify it, you can use ListIterator:

List<String> list = new ArrayList<>();
ListIterator<String> iterator = list.listIterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    if (condition) {
        iterator.remove(); // Safe removal using iterator
    }
}

4. Copy the Collection:

If you need to modify the collection while iterating over it, consider making a copy of the collection and iterating over the copy. This way, modifications won't affect the original collection:

List<String> originalList = new ArrayList<>();
// Add elements to originalList
List<String> copyList = new ArrayList<>(originalList);
for (String element : copyList) {
    if (condition) {
        originalList.remove(element); // Modify originalList
    }
}

5. Use Stream API:

With Java 8 and later, you can use the Stream API to manipulate collections safely:

List<String> list = new ArrayList<>();
list.removeIf(condition); // Safe removal using removeIf() method

AvoidConcurrentModification.java

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class AvoidConcurrentModification {
    public static void main(String[] args) {
        // Create a list
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        // Method 1: Using Iterator's remove() method
        avoidConcurrentModificationWithIterator(list);
        // Method 2: Using for-each loop
        avoidConcurrentModificationWithForEachLoop(list);
        // Method 3: Using ListIterator
        avoidConcurrentModificationWithListIterator(list);
        // Method 4: Copying the collection
        avoidConcurrentModificationByCopying(list);
        // Method 5: Using Stream API (Java 8+)
        avoidConcurrentModificationWithStreamAPI(list);
    }
    // Method 1: Using Iterator's remove() method
    private static void avoidConcurrentModificationWithIterator(List<String> list) {
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            if (element.equals("B")) {
                iterator.remove(); // Safe removal using iterator
            }
        }
        System.out.println("After removing 'B' with Iterator: " + list);
    }
    // Method 2: Using for-each loop
    private static void avoidConcurrentModificationWithForEachLoop(List<String> list) {
        for (Iterator<String> iterator = list.iterator(); iterator.hasNext();) {
            String element = iterator.next();
            if (element.equals("C")) {
                iterator.remove(); // Safe removal using iterator
            }
        }
        System.out.println("After removing 'C' with for-each loop: " + list);
    }
    // Method 3: Using ListIterator
    private static void avoidConcurrentModificationWithListIterator(List<String> list) {
        ListIterator<String> iterator = list.listIterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            if (element.equals("A")) {
                iterator.remove(); // Safe removal using iterator
            }
        }
        System.out.println("After removing 'A' with ListIterator: " + list);
    }
    // Method 4: Copying the collection
    private static void avoidConcurrentModificationByCopying(List<String> list) {
        List<String> copyList = new ArrayList<>(list);
        for (String element : copyList) {
            if (element.equals("B")) {
                list.remove(element); // Modify original list
            }
        }
        System.out.println("After removing 'B' by copying: " + list);
    }
    // Method 5: Using Stream API (Java 8+)
    private static void avoidConcurrentModificationWithStreamAPI(List<String> list) {
        list.removeIf(element -> element.equals("A")); // Safe removal using removeIf() method
        System.out.println("After removing 'A' with Stream API: " + list);
    }
}

Output:

After removing 'B' with Iterator: [A, C]
After removing 'C' with for-each loop: [A]
After removing 'A' with ListIterator: []
After removing 'B' by copying: []
After removing 'A' with Stream API: []

5. Debugging ConcurrentModificationException

When such a problem occurs, you have to analyze your code to find out from which part of your code modification of the collection happens concurrently with the iteration. Once you have identified the problem, you can pick one of the strategies mentioned above to fix it.

ConcurrentModificationExample.java

import java.util.ArrayList;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.List;
public class ConcurrentModificationExample {
    public static void main(String[] args) {
        // Create a list
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        // Attempt to modify the list concurrently while iterating
        try {
            Iterator<String> iterator = list.iterator();
            while (iterator.hasNext()) {
                String element = iterator.next();
                System.out.println("Processing element: " + element);
                if (element.equals("B")) {
                    // Concurrent modification here:
                    System.out.println("Modifying the list while iterating...");
                    iterator.remove(); // Modifying the list while iterating
                    System.out.println("Modified list: " + list);
                }
            }
        } catch (ConcurrentModificationException e) {
            System.out.println("Concurrent modification detected!");
            e.printStackTrace();
        }
    }
}

Output:

Processing element: A
Processing element: B
Modifying the list while iterating...
Modified list: [A, C]
Processing element: C

Next TopicJava Tutorial

← prev next →

ConcurrentModificationException in Java

Example of ConcurrentModificationException

Example

Constructors of ConcurrentModificationException

How to avoid ConcurrentModificationException in a multi-threaded environment?

4.2 How to avoid ConcurrentModificationException in a single-threaded environment?

Contact info

Follow us

Top Tutorials

Interview Questions

Online Compilers

Java Conversion

Java Misc

ConcurrentModificationException in Java

Example of ConcurrentModificationException

Example

Constructors of ConcurrentModificationException

How to avoid ConcurrentModificationException in a multi-threaded environment?

4.2 How to avoid ConcurrentModificationException in a single-threaded environment?

Related Posts

Subscribe to Tpoint Tech

Contact info

Follow us

Top Tutorials

Interview Questions

Online Compilers