CoroutineExceptionHandler in Kotlin - Step-by-Step Execution

Concept Flow - CoroutineExceptionHandler

Start Coroutine

↓

Coroutine runs

↓

Exception thrown?

No→Coroutine completes normally

Yes↓

CoroutineExceptionHandler catches

↓

Handle exception (log, recover, etc.)

↓

Coroutine completes with exception handled

This flow shows how a CoroutineExceptionHandler catches exceptions thrown inside a coroutine and handles them before the coroutine completes.

Execution Sample

Kotlin

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

GlobalScope.launch(handler) {
    throw RuntimeException("Error!")
}

This code launches a coroutine with a CoroutineExceptionHandler that catches and prints any thrown exception.

Execution Table

Step	Action	Exception Thrown?	Handler Called?	Output
1	Coroutine starts running	No	No
2	Exception thrown inside coroutine	Yes	No
3	CoroutineExceptionHandler catches exception	Yes	Yes	Caught: Error!
4	Coroutine completes after handling exception	No	No

💡 Coroutine completes after CoroutineExceptionHandler handles the exception.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
exception	null	RuntimeException("Error!")	RuntimeException("Error!")	Handled

Key Moments - 2 Insights

Why doesn't the exception crash the program?

Because the CoroutineExceptionHandler catches the exception at Step 3 and handles it, preventing a crash.

Is the handler called if no exception is thrown?

No, as shown in Step 1 and 4, the handler is only called when an exception occurs inside the coroutine.

Visual Quiz - 3 Questions

Look at the execution table, at which step does the CoroutineExceptionHandler handle the exception?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Check the 'Handler Called?' column in the execution table.

According to the variable tracker, what is the state of 'exception' after Step 3?

A Handled

B null

C Unhandled exception

D No exception

💡 Hint

Look at the 'exception' row after Step 3 in the variable tracker.

If the coroutine did not throw an exception, what would the handler do?

A Handle a null exception

B Print an error message

C Not be called at all

D Crash the program

💡 Hint

Refer to the 'Handler Called?' column for Step 1 and Step 4 in the execution table.

Concept Snapshot

CoroutineExceptionHandler catches exceptions in coroutines.
Attach it when launching a coroutine.
It handles uncaught exceptions to prevent crashes.
Handler runs only if an exception occurs.
Use it to log or recover from errors.

Full Transcript

This example shows how CoroutineExceptionHandler works in Kotlin coroutines. When a coroutine throws an exception, the handler catches it and runs the code inside its block. This prevents the program from crashing. The execution table traces the coroutine starting, throwing an exception, the handler catching it, and the coroutine completing. The variable tracker shows the exception variable changing from null to handled. Key moments clarify that the handler only runs on exceptions and stops crashes. The quiz tests understanding of when the handler runs and how variables change.