Java ConcurrentModificationException

Introduction

ConcurrentModificationException in Java is a runtime exception that occurs when a collection is modified while iterating over it with methods that are not fail-safe.

Table of Contents

1. What is ConcurrentModificationException?
2. Common Causes
3. How to Avoid ConcurrentModificationException
4. Examples
5. Conclusion

1. What is ConcurrentModificationException?

ConcurrentModificationException is thrown when a thread attempts to modify a collection while another thread is iterating over it, or when the iteration structure is altered unexpectedly.

2. Common Causes

• Modifying a collection directly (e.g., adding or removing elements) while iterating with an iterator.
• Concurrent modifications by multiple threads on the same collection.

3. How to Avoid ConcurrentModificationException

• Use the Iterator's remove() method to safely remove elements during iteration.
• Use concurrent collections like CopyOnWriteArrayList or ConcurrentHashMap for multi-threaded environments.
• Avoid structural modifications during iteration.

4. Examples

Example 1: Causing ConcurrentModificationException

This example demonstrates a scenario that leads to ConcurrentModificationException.

import java.util.ArrayList;
import java.util.List;

public class ConcurrentModificationExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");

        for (String item : list) {
                list.remove(1); // This will cause ConcurrentModificationException
        }
    }
}

Output:

Exception in thread "main" java.util.ConcurrentModificationException
	at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:1095)
	at java.base/java.util.ArrayList$Itr.next(ArrayList.java:1049)
	at net.javaguides.utility.ConcurrentModificationExample.main(ConcurrentModificationExample.java:13)

Example 2: Avoiding ConcurrentModificationException with Iterator

This example shows how to avoid ConcurrentModificationException by using an Iterator.

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

public class IteratorRemoveExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String item = iterator.next();
            if ("B".equals(item)) {
                iterator.remove(); // Safely removing element using iterator
            }
        }
        System.out.println("List after removal: " + list);
    }
}

Output:

List after removal: [A, C]

Example 3: Using CopyOnWriteArrayList to Avoid Issues

This example demonstrates how to use CopyOnWriteArrayList to prevent ConcurrentModificationException.

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

public class CopyOnWriteArrayListExample {
    public static void main(String[] args) {
        List<String> list = new CopyOnWriteArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");

        for (String item : list) {
            if ("B".equals(item)) {
                list.remove(item); // No ConcurrentModificationException here
            }
        }
        System.out.println("List after removal: " + list);
    }
}

Output:

List after removal: [A, C]

5. Conclusion

ConcurrentModificationException is a common issue when working with collections in Java, especially in multi-threaded environments. By using safe practices such as the Iterator's remove() method or concurrent collections, you can avoid this exception and ensure your code runs smoothly.