How to Avoid the ConcurrentModificationException in Kotlin

The ConcurrentModificationException is a very common exception that developers encounter when working with collections in multi-threaded environments. This exception occurs when a collection is concurrently modified while an iterator is traversing through it, causing the operation to fail. It often arises when one thread modifies a collection while another thread is iterating over it.

In Kotlin, as in Java, this exception is primarily designed to detect bugs by throwing an exception rather than allowing unpredictable or non-deterministic behavior to occur.

In this blog, we’ll explore various methods to avoid the ConcurrentModificationException in Kotlin, ensuring your code is both efficient and free from this common exception.

Understanding the ConcurrentModificationException

The ConcurrentModificationException is thrown when a collection is concurrently modified after the iterator is created. The iterator's fail-fast behavior ensures that if a detected concurrent modification occurs, the exception is thrown immediately. This fail quickly mechanism is critical to avoiding the potential pitfalls of unsynchronized concurrent modification, which can lead to non-deterministic behavior in your program.

What Causes the ConcurrentModificationException?

The exception typically occurs in scenarios like:

• Modifying a collection directly while iterating over it using a for loop.

• A different thread modifying the collection while it’s being traversed.

Here's an example in Kotlin that demonstrates this issue:

Copy
val myList = mutableListOf(1, 2, 3, 4)
for (item in myList) {
    if (item == 2) {
        myList.remove(item) // This will throw ConcurrentModificationException
    }
}

Fail-Fast Iterators

In Kotlin, collections like ArrayList use fail-fast iterators. These iterators check for concurrent modification and throw a ConcurrentModificationException as soon as they detect such a modification. This behavior is automatically incorporated into the iterator implementations of many standard collections, ensuring that any unsynchronized concurrent modification is caught on a best-effort basis.

Avoiding the ConcurrentModificationException

1. Use Synchronized Blocks

One approach to avoid this exception is by using a synchronized block around the code that modifies the collection. This ensures that only one thread can access the collection at a time, preventing unsynchronized concurrent modification.

Copy
synchronized(myList) {
    val iterator = myList.iterator()
    while (iterator.hasNext()) {
        if (iterator.next() == 2) {
            iterator.remove() // Safe from ConcurrentModificationException
        }
    }
}

2. Using CopyOnWriteArrayList

Kotlin offers the CopyOnWriteArrayList , which provides a thread-safe alternative to modifying collections. Any modification (like adding or removing elements) results in the creation of a new copy of the list, ensuring that the original list remains unaffected during iteration.

3. Creating a Clone of the List

Another method is to iterate over a copy of the original list, allowing you to remove elements from the original list safely without triggering the exception.

4. Using Iterator’s Remove Method

When you need to modify a collection during iteration, consider using the iterator's remove method. This method removes elements safely without triggering the ConcurrentModificationException.

Handling and Understanding the Exception's Detail Message

Understanding the exception's detail message is crucial for debugging. The detail message about the ConcurrentModificationException usually indicates the method that caused the error and the type of collection being modified. If the exception includes a specified detail message, it might give you hints about the exact nature of the detected concurrent modification.

When this new exception occurs, it is important to read and analyze the class and detail message to understand the underlying cause. For example, if your code throws a ConcurrentModificationException, the specified detail message will usually point out that a modification was attempted on a collection during iteration, which is generally not permissible.

Conclusion

The ConcurrentModificationException is a safeguard in Kotlin that helps you detect bugs and avoid non-deterministic behavior in multi-threaded environments. By using strategies such as synchronized blocks, CopyOnWriteArrayList, and careful iterator usage, you can avoid ConcurrentModificationException and ensure your code operates smoothly even in concurrent scenarios.

Remember, the key is to understand how and when your collections are being modified. By doing so, you can avoid the pitfalls of concurrent modification and keep your applications robust and error-free.

val list = CopyOnWriteArrayList(listOf(1, 2, 3, 4))
for (item in list) {
    if (item == 2) {
        list.remove(item) // Safe from ConcurrentModificationException
    }
}

val listClone = myList.toMutableList()
for (item in listClone) {
    if (item == 2) {
        myList.remove(item) // Modifying original list is safe here
    }
}

val iterator = myList.iterator()
while (iterator.hasNext()) {
    if (iterator.next() == 2) {
        iterator.remove() // Safe removal
    }
}