CoroutineExceptionHandler in Kotlin - Mini Project: Build & Apply

Handling Errors with CoroutineExceptionHandler in Kotlin

📖 Scenario: You are building a simple Kotlin program that runs coroutines to perform tasks. Sometimes, these tasks can fail with errors. You want to catch these errors gracefully and print a message instead of crashing the program.

🎯 Goal: Learn how to use CoroutineExceptionHandler to catch exceptions in coroutines and handle them by printing a friendly error message.

📋 What You'll Learn

Create a coroutine scope with a CoroutineExceptionHandler

Launch a coroutine that throws an exception

Handle the exception using the CoroutineExceptionHandler

Print the error message from the handler

💡 Why This Matters

🌍 Real World

In real apps, coroutines often run background tasks like network calls. Handling errors with CoroutineExceptionHandler helps keep apps stable and user-friendly.

💼 Career

Understanding CoroutineExceptionHandler is important for Kotlin developers working on Android apps or backend services that use coroutines for concurrency.

1

Create a CoroutineExceptionHandler

Create a val called handler and assign it a CoroutineExceptionHandler that prints the message "Caught exception: " followed by the exception's message.

Kotlin

# Your code here
// Create CoroutineExceptionHandler called handler

Hint

Use CoroutineExceptionHandler { _, exception -> } and inside the lambda, print the exception message.

2

Create a CoroutineScope with the handler

Create a val called scope and assign it a CoroutineScope using Dispatchers.Default combined with the handler.

Kotlin

import kotlinx.coroutines.*

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

# Your code here
// Create CoroutineScope called scope with Dispatchers.Default + handler

Hint

Use CoroutineScope(Dispatchers.Default + handler) to combine dispatcher and handler.

3

Launch a coroutine that throws an exception

Use scope.launch to start a coroutine that immediately throws an IllegalArgumentException with the message "Something went wrong".

Kotlin

import kotlinx.coroutines.*

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

val scope = CoroutineScope(Dispatchers.Default + handler)

# Your code here
// Launch coroutine that throws IllegalArgumentException("Something went wrong")

Hint

Inside scope.launch { }, throw the exception with the exact message.

4

Print the error message from the handler

Run the program and print the output. The program should print Caught exception: Something went wrong.

Kotlin

import kotlinx.coroutines.*

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

val scope = CoroutineScope(Dispatchers.Default + handler)

fun main() {
    scope.launch {
        throw IllegalArgumentException("Something went wrong")
    }
    Thread.sleep(100) // Wait to see the output
}

# Your code here
// Run and print output

Hint

Run the program and check the console output matches exactly.

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