Exception handling in coroutines in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of coroutine with try-catch

What is the output of this Kotlin coroutine code snippet?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        try {
            delay(100)
            throw IllegalArgumentException("Error in coroutine")
        } catch (e: IllegalArgumentException) {
            println("Caught: ${e.message}")
        }
    }
    job.join()
    println("Coroutine finished")
}

A Exception in thread "main" java.lang.IllegalArgumentException: Error in coroutine

B

Caught: Error in coroutine
Coroutine finished

C Caught: Error in coroutine

D

Coroutine finished
Caught: Error in coroutine

💡 Hint

Look at where the exception is caught inside the coroutine.

The exception is thrown inside the coroutine but caught by the try-catch block inside the coroutine itself, so the message is printed first. Then after the coroutine finishes, the main prints "Coroutine finished".

❓ Predict Output

intermediate

Exception propagation in coroutine scope

What will be printed when this Kotlin code runs?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val handler = CoroutineExceptionHandler { _, exception ->
        println("Handled: ${exception.message}")
    }
    val job = launch(handler) {
        throw ArithmeticException("Divide by zero")
    }
    job.join()
    println("End of main")
}

A

Handled: Divide by zero
End of main

B Exception in thread "main" java.lang.ArithmeticException: Divide by zero

C

End of main
Handled: Divide by zero

D End of main

💡 Hint

Check how CoroutineExceptionHandler works with launch.

The CoroutineExceptionHandler catches the exception thrown in the launch coroutine and prints the message. Then the main continues and prints "End of main".

🔧 Debug

advanced

Why does this coroutine exception crash the program?

Consider this Kotlin code snippet. Why does the program crash with an unhandled exception?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = async {
        throw IllegalStateException("Failure in async")
    }
    job.await()
    println("This line is never reached")
}

A Because runBlocking does not handle exceptions from child coroutines.

B Because async does not support exceptions and crashes immediately.

C Because exceptions in async are thrown only when awaited, and await is not inside try-catch.

D Because IllegalStateException is not a checked exception and must be caught explicitly.

💡 Hint

Think about when exceptions from async coroutines are delivered.

Exceptions in async coroutines are deferred until await is called. Since await is called without try-catch, the exception propagates and crashes the program.

📝 Syntax

advanced

Correct syntax for catch block in coroutine exception handling

Which option contains the correct syntax for the catch block in Kotlin coroutine exception handling?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val handler = CoroutineExceptionHandler { _, exception ->
        println("Caught: ${exception.message}")
    }
    val job = launch(handler) {
        try {
            throw Exception("Oops")
        } catch e: Exception {
            println("Handled inside try-catch")
        }
    }
    job.join()
}

A catch e: Exception { println("Handled inside try-catch") }

B catch (e: Exception) println("Handled inside try-catch")

C catch { e: Exception -> println("Handled inside try-catch") }

D catch (e: Exception) { println("Handled inside try-catch") }

💡 Hint

The standard Kotlin syntax for catch is 'catch (e: Exception) { ... }'.

B is the correct syntax. In Kotlin, catch blocks require parentheses around the exception parameter: catch (e: Exception) { ... }. Option D misses parentheses, C misses braces for the block, D has wrong syntax.

🚀 Application

expert

How many exceptions are caught and printed?

Given this Kotlin coroutine code, how many exception messages will be printed?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val handler = CoroutineExceptionHandler { _, e ->
        println("Handler caught: ${e.message}")
    }
    val supervisor = SupervisorJob()
    val scope = CoroutineScope(coroutineContext + supervisor + handler)

    val job1 = scope.launch {
        throw RuntimeException("Job1 failed")
    }
    val job2 = scope.launch {
        try {
            throw IllegalArgumentException("Job2 failed")
        } catch (e: IllegalArgumentException) {
            println("Caught in job2: ${e.message}")
        }
    }
    joinAll(job1, job2)
    println("All jobs done")
}

A 2

B 1

C 3

D 0

💡 Hint

Consider which exceptions are caught inside coroutines and which are handled by CoroutineExceptionHandler.

Job1 throws an exception not caught inside, so handler prints its message. Job2 catches its own exception and prints it. So two messages are printed before "All jobs done".