CoroutineExceptionHandler in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a CoroutineExceptionHandler that prints the exception message.

Kotlin

val handler = CoroutineExceptionHandler { _, exception ->
    println("Caught: " + [1].message)
}

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

Ait

Bexception

Cerror

Dthrowable

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong parameter name like 'it' or 'error' which are not defined here.

The exception parameter holds the caught exception, so accessing exception.message prints its message.

2fill in blank

medium

Complete the code to launch a coroutine with the exception handler attached.

Kotlin

GlobalScope.launch([1]) {
    throw RuntimeException("Error!")
}

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

Ahandler

BDispatchers.IO

CDispatchers.Main

DSupervisorJob()

Attempts:

3 left

💡 Hint

Common Mistakes

Passing a dispatcher instead of the exception handler.

The handler is the CoroutineExceptionHandler instance that handles exceptions in the coroutine.

3fill in blank

hard

Fix the error in the CoroutineExceptionHandler usage to properly catch exceptions.

Kotlin

val handler = CoroutineExceptionHandler { _, [1] ->
    println("Caught: " + exception.message)
}

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

Aexception

Berror

Cthrowable

De

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different parameter name but referencing 'exception' inside the block.

The lambda parameter must be named exception to match the usage inside the block.

4fill in blank

hard

Fill both blanks to create a CoroutineScope with a SupervisorJob and the exception handler.

Kotlin

val scope = CoroutineScope([1] + [2])

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

ASupervisorJob()

Bhandler

CDispatchers.Default

DJob()

Attempts:

3 left

💡 Hint

Common Mistakes

Using Job() instead of SupervisorJob().

Not including the exception handler.

Combining SupervisorJob() and handler creates a scope that supervises child coroutines and handles exceptions.

5fill in blank

hard

Fill all three blanks to define a CoroutineExceptionHandler that logs the error, then launch a coroutine with it and a dispatcher.

Kotlin

val handler = CoroutineExceptionHandler { _, [1] ->
    println("Error: " + [2].message)
}

GlobalScope.launch([3] + handler) {
    throw IllegalStateException("Oops")
}

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

Aexception

CDispatchers.Default

DDispatchers.IO

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for the exception parameter and inside the block.

Omitting the dispatcher or using the wrong one.

The exception parameter is named exception in the handler, used to print the message. The coroutine is launched with Dispatchers.Default plus the handler.

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