Avoid ConcurrentModificationException in Java

1. Introduction

Java developers frequently see concurrent modification exceptions when working with collections. Unpredictable behaviour in the application results when a collection is altered while iterated. This article’ll review prevention methods and how to avoid ConcurrentModificationException in Java.

Knowing the underlying causes of ConcurrentModificationException management is essential for building reliable Java applications. This issue occurs when multiple threads visit the same collection simultaneously or when changing a collection. At the same time, it is being iterated, resulting in an inconsistent state for the iterators. We must use methods that guarantee thread safety and adequate iteration while working with collections to prevent this issue effectively.

Several approaches can be applied to avoid concurrent modification exception, including using concurrent collections, iterator removal methods, working with streams, and adopting synchronization techniques. By implementing these practices, you can improve your Java application’s reliability and ensure smooth execution in multi-threaded environments.

Key Takeaways

ConcurrentModificationException occurs when a collection is modified during iteration or accessed by multiple threads.
Avoid the exception using concurrent collections, iterator removal methods, and synchronization techniques.
Adopting proper strategies enhances your Java application’s reliability in multi-threaded environments.

---

2. Example of ConcurrentModificationException

ConcurrentModificationException is an unchecked exception when a collection is modified while iterating over it. This very common exception prevents unpredictable behaviour and potential data corruption in multi-threaded environments.

To illustrate the issue, let’s consider a simple example using an ArrayList:

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

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

        for (String item : items) {
            if (item.equals("B")) {
                items.remove(item);
            }
        }
    }
}

In the code above, we are trying to remove the same object from the ArrayList while iterating it. Running this code will result in a ConcurrentModificationException because we attempt to modify the collection during iteration.

---

3. Avoid ConcurrentModificationException in Java

One approach to avoid this exception in a single-threaded environment is to use an Iterator, which allows us to remove elements while iterating through a collection safely. Here’s a revised version of the example above:

3.1. Using Iterator

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

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

        Iterator<String> iterator = items.iterator();
        while (iterator.hasNext()) {
            String item = iterator.next();
            if (item.equals("B")) {
                iterator.remove();
            }
        }
    }
}

In this case, no ConcurrentModificationException is thrown because we use the Iterator’s remove() method to remove elements from the collection while iterating it safely.

Another approach to circumvent the ConcurrentModificationException in a single-threaded environment is using a concurrent collection, such as java.util.concurrent.CopyOnWriteArrayList or ConcurrentHashMap. These collections are designed to handle concurrent modifications.

Still, they come with potential performance tradeoffs, so it’s essential to consider the specific needs of your application before choosing one over a standard collection.

In summary, we can avoid ConcurrentModificationException by using an Iterator to safely remove elements during iteration or concurrent collections specifically designed for such use cases. Always consider the needs of your application and the tradeoffs involved when deciding which approach to take.

3.2. Utilizing New Collection

An alternative approach is to use a separate collection to hold all the elements to be removed. While we iterate, our conditions capture all the elements to be removed after we use removeAll() method to remove all required elements.

public static void avoidUsingExtraCollection(List<String> elements) {
    List<String> elementsToDelete = new ArrayList<>();
    for (String element : elements) {
        if (element.equals("4")) {
            elementsToDelete.add(element);
        }
    }
    elements.removeAll(elementsToDelete);
}

3.3. Using Concurrent Collections

The CopyOnWriteArrayList is part of the java.util.concurrent package. It is a thread-safe, dynamic array that allows us to perform modifications even while iterating. A new copy of the underlying array is created whenever a modification is performed so that the changes won’t affect ongoing iterations.

Here’s a simple example using the CopyOnWriteArrayList:

import java.util.concurrent.CopyOnWriteArrayList;

public class Main {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = 
            new CopyOnWriteArrayList<>();

        // Adding elements
        list.add("Apple");
        list.add("Orange");
        list.add("Banana");

        // Removing elements while iterating
        for (String item : list) {
            if (item.length() > 5) {
                list.remove(item);
            }
        }
    }
}

ConcurrentHashMap is a high-performance concurrent implementation of the java.util.Map interface, also available in the java.util.concurrent package. It’s designed to handle modifications safely.

Using ConcurrentHashMap can help avoid ConcurrentModificationExceptions in your Java code. Here’s an code snippet example:

import java.util.concurrent.ConcurrentHashMap;

public class Main {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map =
            new ConcurrentHashMap<>();

        // Adding key-value pairs
        map.put("one", 1);
        map.put("two", 2);
        map.put("three", 3);

        // Removing elements while iterating
        for (String key : map.keySet()) {
            if (key.length() > 3) {
                map.remove(key);
            }
        }
    }
}

By using CopyOnWriteArrayList and ConcurrentHashMap appropriately in your Java programs, you can avoid the dreaded ConcurrentModificationException.

3.4. Using Stream Collectors

Also, we can use Streams for sequential processing while preventing ConcurrentModificationException in a single-threaded environment. Streams operate using an internal iteration algorithm (Java takes care of the iteration process), so we can focus on “what” to do rather than “how”. We filter the above collection to only include divisible elements by 2. We create a new list using the collect method because streams don’t mutate the source.

public static void avoidUsingStreams(List<String> elements) {
    List<String> filteredElements = elements.stream()
            .filter(element -> Integer.parseInt(element) % 2 == 0)
            .collect(Collectors.toList());
}

3.5. Parallel Streams

Another technique to prevent ConcurrentModificationException is by using parallel streams. Parallel streams enable us to process elements concurrently, reducing the risk of simultaneous modifications. To create a parallel stream, use the parallelStream() method on a collection.

List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three"));
Stream<String> parallelStream = list.parallelStream();

When using parallel streams, it’s crucial to ensure that any operations performed on the stream are thread-safe. 

3.6. Java 8 removeIf()

public static void avoidUsingRemoveIf(List<String> elements) {
    elements.removeIf(element -> Integer.parseInt(element) % 2 == 0);
    System.out.println(Arrays.toString(elements.toArray()));
}

Finally, the verbose solution removeIf() can achieve removal in a single line. It will remove all the elements that evaluate true for the given predicate. Internally the removeIf() method uses an iterator with a while loop similar to the example from the previous sections.

3.7. Synchronization Techniques

Java provides a synchronized block to create synchronized versions of various collection classes. These methods ensure that all operations on the collection are synchronized. Here’s a sample code for using a synchronizedList:

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

synchronized(synchronizedList) {
    Iterator<String> iterator = synchronizedList.iterator();

    while (iterator.hasNext()) {
        String element = iterator.next();
        // Perform operations on element
    }
}

Remember that using synchronized collections doesn’t eliminate the possibility of ConcurrentModificationException. You must still synchronize access to the iterator while iterating through the collection.

Another approach to avoid ConcurrentModificationException is using Locks and Conditions to manage access to shared resources in a multi-threaded environment. The java.util.concurrent.locks package provides robust locking mechanisms for better synchronization control.

Here’s an example of a code snippet using ReentrantLock and Condition:

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();

// In a read thread
lock.lock();
try {
    while (someCondition) {
        // Release the lock and wait for signal
        condition.await();
    }
    // Read or Iterate the collection
} finally {
    lock.unlock();
}

// In a write/modifying thread
lock.lock();
try {
    // Modify the collection
    // Signal all waiting threads
    condition.signalAll();
} finally {
    lock.unlock();
}

Using Locks and Conditions allows for fine-grained control over synchronization and ensures proper execution order, helping to prevent ConcurrentModificationException.

---

4. Summary

This article has looked at how to avoid ConcurrentModificationException in Java. Are you looking to operate your Java code without the fear of ConcurrentModificationException raising its pesky head? We’ve got you covered. Depending on needs and wants, there are multiple ways to ensure this exception stays far away from crashing your program – choose wisely!