CoroutineExceptionHandler in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this CoroutineExceptionHandler example?

Consider the following Kotlin code using CoroutineExceptionHandler. What will be printed when this code runs?

Kotlin

import kotlinx.coroutines.*

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

    val job = GlobalScope.launch(handler) {
        throw AssertionError("My custom error")
    }
    job.join()
    println("Done")
}

A No output

B Exception is not caught, program crashes

C

Caught: My custom error
Done

D

Done
Caught: My custom error

💡 Hint

CoroutineExceptionHandler catches uncaught exceptions in coroutines launched with it.

The CoroutineExceptionHandler catches the AssertionError thrown inside the coroutine and prints the message. Then the main coroutine prints "Done" after job.join().

❓ Predict Output

intermediate

What happens if CoroutineExceptionHandler is used with async builder?

Look at this Kotlin code snippet. What will be the output or behavior?

Kotlin

import kotlinx.coroutines.*

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

    val deferred = async(handler) {
        throw IllegalStateException("Error in async")
    }

    try {
        deferred.await()
    } catch (e: Exception) {
        println("Caught in try: ${e.message}")
    }
}

A

Caught: Error in async
Caught in try: Error in async

B Caught in try: Error in async

C Caught: Error in async

D No output, program hangs

💡 Hint

CoroutineExceptionHandler does not catch exceptions from async builder.

Exceptions in async coroutines are deferred until await is called. CoroutineExceptionHandler does not catch these exceptions. The exception is caught in the try-catch around await.

🔧 Debug

advanced

Why does this CoroutineExceptionHandler not catch the exception?

This Kotlin code uses CoroutineExceptionHandler but the exception is not caught by it. Why? fun main() = runBlocking { val handler = CoroutineExceptionHandler { _, exception -> println("Caught: ${exception.message}") } val job = launch { throw RuntimeException("Oops") } job.join() println("Finished") }

A Because the handler was not passed to launch, so it can't catch exceptions

B Because runBlocking swallows exceptions silently

C Because RuntimeException is not caught by CoroutineExceptionHandler

D Because job.join() suppresses exceptions

💡 Hint

CoroutineExceptionHandler must be passed to the coroutine builder to work.

The handler is defined but not used in launch. Without passing it as a context element, exceptions are not caught by it.

📝 Syntax

advanced

Which option correctly creates a CoroutineExceptionHandler?

Select the correct Kotlin syntax to create a CoroutineExceptionHandler that prints the exception message.

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

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

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

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

💡 Hint

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

Option D uses the correct lambda syntax with two parameters. Options A, C, and D have syntax errors or wrong parameter usage.

🚀 Application

expert

How many exceptions will be caught by this CoroutineExceptionHandler?

Given this Kotlin code, how many exceptions will the CoroutineExceptionHandler catch and print?

Kotlin

import kotlinx.coroutines.*

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

    val supervisor = SupervisorJob()
    val scope = CoroutineScope(coroutineContext + supervisor + handler)

    scope.launch {
        throw IllegalArgumentException("First error")
    }

    scope.launch {
        try {
            throw IllegalStateException("Second error")
        } catch (e: Exception) {
            println("Caught locally: ${e.message}")
        }
    }

    scope.async {
        throw ArithmeticException("Third error")
    }

    delay(100)
}

A 1

B 3

C 2

D 0

💡 Hint

CoroutineExceptionHandler catches uncaught exceptions in launch coroutines but not in async or caught exceptions.

The first launch throws an uncaught exception caught by handler. The second launch catches its own exception locally. The async throws an exception that is not caught by handler because async exceptions are deferred until await, which is not called here.