CoroutineExceptionHandler in Kotlin - Time & Space Complexity

Time Complexity: CoroutineExceptionHandler

O(n)

Understanding Time Complexity

We want to understand how the time it takes to handle exceptions in coroutines changes as the number of coroutines grows.

How does adding more coroutines affect the cost of exception handling?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

val handler = CoroutineExceptionHandler { _, exception ->
    println("Caught exception: ${exception.message}")
}

val scope = CoroutineScope(Dispatchers.Default + handler)

repeat(n) {
    scope.launch {
        throw RuntimeException("Error in coroutine $it")
    }
}
    

This code launches n coroutines, each throwing an exception handled by CoroutineExceptionHandler.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Launching n coroutines each throwing an exception.
• How many times: The exception handler is invoked once per coroutine that throws an exception, so n times.

How Execution Grows With Input

As the number of coroutines n increases, the number of exception handling calls grows linearly.

Input Size (n)	Approx. Operations
10	10 exception handler calls
100	100 exception handler calls
1000	1000 exception handler calls

Pattern observation: The work grows directly in proportion to the number of coroutines throwing exceptions.

Final Time Complexity

Time Complexity: O(n)

This means the time to handle exceptions grows linearly with the number of coroutines that throw exceptions.

Common Mistake

[X] Wrong: "Exception handling in coroutines happens instantly and does not depend on how many coroutines run."

[OK] Correct: Each coroutine that throws an exception triggers the handler separately, so more coroutines mean more handling work.

Interview Connect

Understanding how exception handling scales in asynchronous code shows you can reason about performance in real-world concurrent programs.

Self-Check

What if we changed the code to launch coroutines that sometimes do not throw exceptions? How would the time complexity of exception handling change?