Exception handling in coroutines in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to catch exceptions inside a coroutine.

Kotlin

launch {
    try {
        // Some suspending function
        fetchData()
    } catch ([1]: Exception) {
        println("Error caught")
    }
}

Drag options to blanks, or click blank then click option'

Ae

Berror

Cex

Dexception

Attempts:

3 left

💡 Hint

Common Mistakes

Using a keyword or invalid variable name in catch block.

Not providing a variable name after catch.

The variable e is commonly used to catch exceptions in Kotlin. It holds the caught exception object.

2fill in blank

medium

Complete the code to handle exceptions globally in a CoroutineScope.

Kotlin

val handler = CoroutineExceptionHandler { _, [1] ->
    println("Caught $[1]")
}

CoroutineScope(Dispatchers.Default + handler).launch {
    throw RuntimeException("Fail")
}

Drag options to blanks, or click blank then click option'

Athrowable

Berror

Ce

Dexception

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect parameter names that don't match the handler signature.

Confusing the exception variable with the context.

The CoroutineExceptionHandler receives a Throwable as the second parameter, commonly named throwable.

3fill in blank

hard

Fix the error in the coroutine exception handling code.

Kotlin

val handler = CoroutineExceptionHandler { _, throwable ->
    println("Caught: $[1]")
}

GlobalScope.launch(handler) {
    throw Exception("Oops")
}

Drag options to blanks, or click blank then click option'

Aerror

Bthrowable

Ce

Dex

Attempts:

3 left

💡 Hint

Common Mistakes

Referencing a variable name not declared in the lambda parameters.

Using a different variable name inside the lambda body.

The variable throwable is the correct name used in the lambda parameter and must be referenced inside the lambda.

4fill in blank

hard

Fill both blanks to create a map of word lengths filtering words longer than 3 characters.

Kotlin

val words = listOf("cat", "house", "dog", "elephant")
val lengths = words.associateWith { it.[1] }
    .filter { it.value [2] 3 }

Drag options to blanks, or click blank then click option'

Alength

B>

C<

Dcount

Attempts:

3 left

💡 Hint

Common Mistakes

Using count without parentheses which is a function.

Using wrong comparison operators like < instead of >.

length gets the length of the string, and > filters words longer than 3 characters.

5fill in blank

hard

Fill all three blanks to create a map of uppercase keys and values filtered by positive values.

Kotlin

val data = mapOf("a" to 1, "b" to -2, "c" to 3)
val result = data.mapKeys { it.key.[1]() }
    .filter { it.value [2] 0 }
    .mapValues { it.[3] }

Drag options to blanks, or click blank then click option'

AtoUpperCase

B>

Cvalue

DtoLowerCase

Attempts:

3 left

💡 Hint

Common Mistakes

Using toLowerCase() instead of uppercase.

Filtering with wrong comparison operator.

Using key instead of value in mapValues.

toUpperCase() converts keys to uppercase, > filters positive values, and value returns the map's value.

Practice

1. What is the primary way to catch exceptions inside a Kotlin coroutine launched with launch?

easy

A. Use try-catch block inside the coroutine code

B. Use catch method on the coroutine builder

C. Use finally block outside the coroutine

D. Exceptions cannot be caught in coroutines

Solution

1. Step 1: Understand coroutine exception handling basics

   Exceptions inside launch coroutines are caught by try-catch blocks within the coroutine code itself.

2. Step 2: Identify correct method to catch exceptions

   The catch method does not exist on coroutine builders, and finally outside coroutine does not catch coroutine exceptions.

3. Final Answer:

   Use try-catch block inside the coroutine code -> Option A

4. Quick Check:

   try-catch inside coroutine = correct way [OK]

Hint: Catch exceptions inside coroutine with try-catch [OK]

Common Mistakes:

• Thinking catch method exists on coroutine builders
• Using finally block outside coroutine to catch exceptions
• Assuming exceptions cannot be caught in coroutines

2. Which of the following is the correct syntax to define a CoroutineExceptionHandler in Kotlin?

easy

A. val handler = CoroutineExceptionHandler { println(exception) }

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

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

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

Solution

1. Step 1: Recall CoroutineExceptionHandler signature

   It takes a lambda with two parameters: context and exception.

2. Step 2: Match correct syntax

   val handler = CoroutineExceptionHandler { context, exception -> println(exception) } correctly uses the two parameters in the lambda. Other options miss parameters or have wrong syntax.

3. Final Answer:

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

4. Quick Check:

   CoroutineExceptionHandler requires (context, exception) lambda [OK]

Hint: CoroutineExceptionHandler lambda needs context and exception [OK]

Common Mistakes:

• Omitting context parameter in lambda
• Passing parameters incorrectly
• Using invalid constructor syntax

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

import kotlinx.coroutines.*

fun main() = runBlocking {
    val handler = CoroutineExceptionHandler { _, exception ->
        println("Caught: ${exception.message}")
    }
    val job = launch(handler) {
        throw IllegalArgumentException("Invalid argument")
    }
    job.join()
    println("Done")
}

medium

A. Caught: Invalid argument
Done

B. Exception in thread "main" java.lang.IllegalArgumentException: Invalid argument

C. Done

D. Caught: null
Done

Solution

1. Step 1: Understand CoroutineExceptionHandler usage

   The handler catches exceptions thrown inside the launch coroutine and prints the message.

2. Step 2: Trace program output

   The exception message "Invalid argument" is printed by the handler, then "Done" is printed after job.join().

3. Final Answer:

   Caught: Invalid argument Done -> Option A

4. Quick Check:

   Exception caught by handler, then Done printed [OK]

Hint: ExceptionHandler prints message, then main continues [OK]

Common Mistakes:

• Expecting uncaught exception crash
• Missing that handler catches exception
• Ignoring job.join() effect

4. Identify the error in this Kotlin coroutine exception handling code:

import kotlinx.coroutines.*

fun main() = runBlocking {
    val handler = CoroutineExceptionHandler { _, exception ->
        println("Error: ${exception.message}")
    }
    val job = async(handler) {
        throw RuntimeException("Failure")
    }
    job.await()
}

medium

A. Missing try-catch block inside async coroutine

B. The handler lambda parameters are incorrect

C. CoroutineExceptionHandler does not catch exceptions from async coroutines

D. Using runBlocking incorrectly

Solution

1. Step 1: Understand exception handling difference between launch and async

   Exceptions in async are propagated via the deferred result and must be caught by try-catch on await().

2. Step 2: Analyze why CoroutineExceptionHandler fails here

   CoroutineExceptionHandler does not catch exceptions from async coroutines because they are deferred until await().

3. Final Answer:

   CoroutineExceptionHandler does not catch exceptions from async coroutines -> Option C

4. Quick Check:

   async exceptions need try-catch on await() [OK]

Hint: Use try-catch on await() for async exceptions [OK]

Common Mistakes:

• Expecting CoroutineExceptionHandler to catch async exceptions
• Ignoring need for try-catch on await()
• Misunderstanding handler lambda parameters

5. You want to handle exceptions from multiple launch coroutines in a Kotlin app and log errors without stopping other coroutines. Which approach is best?

hard

A. Use async coroutines and catch exceptions on await()

B. Attach a shared CoroutineExceptionHandler to the parent scope and launch coroutines within it

C. Wrap each coroutine body in a try-catch block and ignore exceptions

D. Use SupervisorJob without any exception handling

Solution

1. Step 1: Understand exception handling for multiple launch coroutines

   Using a shared CoroutineExceptionHandler on the parent scope catches exceptions from all child launch coroutines without cancelling siblings.

2. Step 2: Evaluate other options

   Wrapping each coroutine in try-catch is verbose and error-prone; async with await is for deferred results; SupervisorJob alone does not handle exceptions or logging.

3. Final Answer:

   Attach a shared CoroutineExceptionHandler to the parent scope and launch coroutines within it -> Option B

4. Quick Check:

   Shared handler on parent scope manages launch exceptions [OK]

Hint: Use shared CoroutineExceptionHandler on parent for launch coroutines [OK]

Common Mistakes:

• Ignoring shared handler benefits
• Using async instead of launch for fire-and-forget
• Not handling exceptions leads to crashes