Kotlin ConcurrentModificationException

Introduction

In Kotlin, ConcurrentModificationException is a runtime exception that is thrown when an object is modified concurrently while it is being iterated over. This exception is part of the Kotlin (and Java) standard library and usually occurs when a collection is modified while iterating through it using an iterator, without using the iterator's remove method.

Table of Contents

1. What is ConcurrentModificationException?
2. Common Causes of ConcurrentModificationException
3. Handling ConcurrentModificationException
4. Examples of ConcurrentModificationException
5. Real-World Use Case
6. Conclusion

1. What is ConcurrentModificationException?

ConcurrentModificationException is a subclass of RuntimeException and is thrown to indicate that a collection has been modified concurrently when it is not allowed. This exception is usually thrown when a collection is modified while iterating through it, either by another thread or by the same thread but outside of the iterator's control.

Syntax

throw ConcurrentModificationException("Exception message")

2. Common Causes of ConcurrentModificationException

• Modifying a collection directly while iterating through it.
• Using methods that modify the collection during iteration, like add or remove, instead of using the iterator's methods.

Example

fun main() {
    val list = mutableListOf(1, 2, 3, 4, 5)
    for (item in list) {
        if (item == 3) {
            list.remove(item) // This will cause ConcurrentModificationException
        }
    }
}

3. Handling ConcurrentModificationException

You can handle ConcurrentModificationException by using the iterator's remove method or by collecting the items to be removed in a separate list and then removing them after the iteration.

Using Iterator's remove Method

fun main() {
    val list = mutableListOf(1, 2, 3, 4, 5)
    val iterator = list.iterator()
    while (iterator.hasNext()) {
        val item = iterator.next()
        if (item == 3) {
            iterator.remove() // Safe removal
        }
    }
    println(list)
}

Collecting Items to Remove

fun main() {
    val list = mutableListOf(1, 2, 3, 4, 5)
    val itemsToRemove = mutableListOf<Int>()
    for (item in list) {
        if (item == 3) {
            itemsToRemove.add(item)
        }
    }
    list.removeAll(itemsToRemove)
    println(list)
}

4. Examples of ConcurrentModificationException

Example 1: Modifying Collection During Iteration

This example demonstrates a common cause of ConcurrentModificationException.

fun main() {
    val list = mutableListOf(1, 2, 3, 4, 5)
    try {
        for (item in list) {
            if (item == 3) {
                list.remove(item)
            }
        }
    } catch (e: ConcurrentModificationException) {
        println("Caught a concurrent modification exception: ${e.message}")
    }
}

Output:

Caught a concurrent modification exception: null

Explanation:
This example catches and handles a ConcurrentModificationException caused by modifying a collection during iteration.

Example 2: Safe Removal Using Iterator

This example demonstrates how to safely remove an item from a collection using an iterator.

fun main() {
    val list = mutableListOf(1, 2, 3, 4, 5)
    val iterator = list.iterator()
    while (iterator.hasNext()) {
        val item = iterator.next()
        if (item == 3) {
            iterator.remove() // Safe removal
        }
    }
    println(list) // Output: [1, 2, 4, 5]
}

Explanation:
This example shows how to use the iterator's remove method to safely remove an item from a collection during iteration.

Example 3: Modifying Collection in a Separate List

This example demonstrates how to safely modify a collection by collecting items to be removed in a separate list.

fun main() {
    val list = mutableListOf(1, 2, 3, 4, 5)
    val itemsToRemove = mutableListOf<Int>()
    for (item in list) {
        if (item == 3) {
            itemsToRemove.add(item)
        }
    }
    list.removeAll(itemsToRemove)
    println(list) // Output: [1, 2, 4, 5]
}

Explanation:
This example shows how to collect items to be removed in a separate list and then remove them after the iteration to avoid ConcurrentModificationException.

5. Real-World Use Case: Removing Elements Based on a Condition

In a real-world scenario, you might need to remove elements from a collection based on a condition without causing ConcurrentModificationException.

Example: Removing Elements Based on a Condition

fun removeNegativeNumbers(numbers: MutableList<Int>) {
    val iterator = numbers.iterator()
    while (iterator.hasNext()) {
        if (iterator.next() < 0) {
            iterator.remove()
        }
    }
}

fun main() {
    val numbers = mutableListOf(1, -2, 3, -4, 5)
    removeNegativeNumbers(numbers)
    println(numbers) // Output: [1, 3, 5]
}

Explanation:
This example shows how to safely remove negative numbers from a list using the iterator's remove method to avoid ConcurrentModificationException.

Conclusion

ConcurrentModificationException in Kotlin is a runtime exception that occurs when a collection is modified concurrently while being iterated over. By understanding how to handle ConcurrentModificationException using safe practices like using the iterator's remove method or collecting items to remove in a separate list, you can write more robust and error-resistant code. Proper handling of concurrent modifications is crucial in real-world applications to ensure data integrity and prevent runtime exceptions.