CoroutineExceptionHandler in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is CoroutineExceptionHandler in Kotlin coroutines?

CoroutineExceptionHandler is a special interface in Kotlin that lets you handle uncaught exceptions in coroutines. It acts like a global error catcher for coroutine failures.

beginner

How do you add a CoroutineExceptionHandler to a coroutine?

You create a CoroutineExceptionHandler instance and add it to the coroutine context using the + operator when launching the coroutine.

Example:
val handler = CoroutineExceptionHandler { _, exception -> println("Caught: $exception") }
GlobalScope.launch(handler) { /* code */ }

intermediate

When does CoroutineExceptionHandler catch exceptions?

It catches exceptions only from uncaught exceptions in root coroutines or coroutines launched with launch. It does not catch exceptions from async coroutines because those exceptions are deferred until you call await().

beginner

What happens if you don't provide a CoroutineExceptionHandler?

If no CoroutineExceptionHandler is provided, uncaught exceptions in coroutines are handled by the default exception handler, which usually prints the stack trace and may crash the application.

intermediate

Can CoroutineExceptionHandler handle exceptions from async coroutines automatically?

No. Exceptions from async coroutines are captured and only thrown when you call await(). You need to handle them with try-catch around await() or use other mechanisms.

What is the primary role of CoroutineExceptionHandler in Kotlin coroutines?

A To catch uncaught exceptions in coroutines

B To start a new coroutine

C To cancel running coroutines

D To delay coroutine execution

CoroutineExceptionHandler is designed to catch uncaught exceptions in coroutines.

Which coroutine builder's exceptions can CoroutineExceptionHandler catch automatically?

A <code>runBlocking</code>

B <code>async</code>

C <code>launch</code>

D <code>withContext</code>

Exceptions from launch coroutines are caught by CoroutineExceptionHandler. Exceptions from async are deferred.

How do you add a CoroutineExceptionHandler to a coroutine?

A By adding it to the coroutine context with the <code>+</code> operator

B By calling a special function inside the coroutine

C By wrapping the coroutine in a try-catch block

D By using <code>runCatching</code> on the coroutine

You add CoroutineExceptionHandler to the coroutine context using the + operator when launching the coroutine.

What happens if an exception is thrown in an async coroutine and you don't call await()?

A The exception is ignored

B The exception is caught by <code>CoroutineExceptionHandler</code>

C The exception crashes the program immediately

D The exception is not thrown until <code>await()</code> is called

Exceptions in async coroutines are deferred and only thrown when await() is called.

If you want to handle exceptions from an async coroutine, what should you do?

A Add a <code>CoroutineExceptionHandler</code>

B Use try-catch around <code>await()</code>

C Use <code>launch</code> instead of <code>async</code>

D Ignore exceptions because they are handled automatically

Exceptions from async must be handled by try-catch around await().

Explain what CoroutineExceptionHandler is and how it works in Kotlin coroutines.

Think about how exceptions behave differently in launch and async coroutines.

Describe a scenario where CoroutineExceptionHandler would not catch an exception and how you would handle it.

Focus on async coroutines and deferred exceptions.

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