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.

Practice

1. What is the main purpose of CoroutineExceptionHandler in Kotlin coroutines?

easy

A. To delay coroutine execution by a fixed time

B. To launch new coroutines in a specific thread

C. To cancel running coroutines immediately

D. To catch uncaught exceptions in coroutines and handle them

Solution

1. Step 1: Understand CoroutineExceptionHandler role

   It is designed to catch exceptions that are not handled inside coroutines.

2. Step 2: Compare with other coroutine features

   Launching coroutines, cancelling, or delaying are different coroutine features, not related to exception handling.

3. Final Answer:

   To catch uncaught exceptions in coroutines and handle them -> Option D

4. Quick Check:

   CoroutineExceptionHandler catches exceptions = A [OK]

Hint: Remember: ExceptionHandler catches errors outside try-catch [OK]

Common Mistakes:

• Confusing CoroutineExceptionHandler with coroutine launch or delay
• Thinking it cancels coroutines instead of handling exceptions
• Assuming it handles exceptions inside try-catch blocks

2. Which of the following is the correct way to create a CoroutineExceptionHandler in Kotlin?

easy

A. val handler = CoroutineExceptionHandler { context, exception -> println(exception) }

B. val handler = CoroutineExceptionHandler(context, exception -> println(exception))

C. val handler = CoroutineExceptionHandler(context) { exception -> println(exception) }

D. val handler = CoroutineExceptionHandler { exception -> println(exception) }

Solution

1. Step 1: Recall CoroutineExceptionHandler syntax

   It takes a lambda with two parameters: CoroutineContext and Throwable.

2. Step 2: Check options for correct lambda signature

   val handler = CoroutineExceptionHandler { context, exception -> println(exception) } matches the correct syntax: { context, exception -> ... }.

3. Final Answer:

   val handler = CoroutineExceptionHandler { context, exception -> println(exception) } -> Option A

4. Quick Check:

   Correct lambda parameters = A [OK]

Hint: Remember: Handler lambda needs (context, exception) parameters [OK]

Common Mistakes:

• Using only one parameter in lambda
• Passing parameters incorrectly with parentheses
• Confusing syntax with other coroutine builders

3. What will be the output of the following Kotlin code?

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

GlobalScope.launch(handler) {
    throw IllegalArgumentException("Invalid argument")
}
Thread.sleep(100)

medium

A. Caught: java.lang.IllegalArgumentException

B. Caught: Invalid argument

C. No output, exception ignored

D. Exception not caught, program crashes

Solution

1. Step 1: Understand CoroutineExceptionHandler usage

   The handler catches uncaught exceptions and prints the message.

2. Step 2: Analyze the thrown exception message

   The exception is IllegalArgumentException with message "Invalid argument".

3. Final Answer:

   Caught: Invalid argument -> Option B

4. Quick Check:

   Exception message printed = D [OK]

Hint: Exception message prints inside handler lambda [OK]

Common Mistakes:

• Expecting program crash instead of caught exception
• Confusing exception object with its message
• Ignoring Thread.sleep needed for coroutine to run

4. Identify the error in this Kotlin coroutine code using CoroutineExceptionHandler:

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

GlobalScope.launch {
    throw RuntimeException("Failure")
}

medium

A. Exception type is wrong

B. Lambda parameters are incorrect

C. CoroutineExceptionHandler is not added to coroutine context

D. GlobalScope.launch cannot throw exceptions

Solution

1. Step 1: Check how handler is used

   The handler is defined but not passed to launch coroutine context.

2. Step 2: Understand consequence

   Without adding handler to launch, exceptions are uncaught and not handled by it.

3. Final Answer:

   CoroutineExceptionHandler is not added to coroutine context -> Option C

4. Quick Check:

   Handler must be in launch context = C [OK]

Hint: Always add handler to launch context: launch(handler) [OK]

Common Mistakes:

• Defining handler but forgetting to use it in launch
• Assuming handler works globally without context
• Misunderstanding lambda parameter names

5. You want to handle exceptions from multiple coroutines launched in a CoroutineScope using a single CoroutineExceptionHandler. Which approach correctly applies the handler to all coroutines?

hard

A. Add the CoroutineExceptionHandler to the CoroutineScope's context when creating it

B. Add the handler only to the first coroutine launched

C. Wrap each coroutine's code in try-catch instead of using CoroutineExceptionHandler

D. Use a global try-catch block outside all coroutines

Solution

1. Step 1: Understand CoroutineScope context inheritance

   Coroutines inherit context from their CoroutineScope, including exception handlers.

2. Step 2: Apply handler to CoroutineScope context

   Adding CoroutineExceptionHandler to the scope ensures all launched coroutines use it automatically.

3. Final Answer:

   Add the CoroutineExceptionHandler to the CoroutineScope's context when creating it -> Option A

4. Quick Check:

   Handler in scope context applies to all coroutines = B [OK]

Hint: Attach handler to scope context for all coroutines [OK]

Common Mistakes:

• Adding handler only to some coroutines
• Relying on try-catch inside coroutines instead
• Using global try-catch which doesn't catch coroutine exceptions