SupervisorJob for independent failure in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kotlin coroutine code using SupervisorJob?

Consider the following Kotlin code snippet using SupervisorJob. What will be printed when it runs?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val supervisor = SupervisorJob()
    val scope = CoroutineScope(coroutineContext + supervisor)

    val child1 = scope.launch {
        delay(100)
        println("Child 1 completed")
    }

    val child2 = scope.launch {
        delay(50)
        throw RuntimeException("Child 2 failed")
    }

    child1.join()
    try {
        child2.join()
    } catch (e: Exception) {
        // Child 2 failure ignored
    }
    println("Scope is active: ${scope.isActive}")
}

A Child 2 failed exception is ignored, Child 1 is cancelled, then prints: Scope is active: false

B Child 2 failed exception is thrown and Child 1 is cancelled, no further output.

C Child 2 failed exception is thrown, Child 1 completes, then prints: Scope is active: false

D Child 2 failed exception is ignored, Child 1 completes, then prints: Scope is active: true

💡 Hint

SupervisorJob allows child coroutines to fail independently without cancelling siblings.

SupervisorJob lets child coroutines fail without cancelling other children or the parent scope. So, Child 2's failure does not cancel Child 1, which completes successfully. The scope remains active.

🧠 Conceptual

intermediate

Why use SupervisorJob in Kotlin coroutines?

Which of the following best explains the main purpose of using SupervisorJob in Kotlin coroutines?

A To ensure that if one child coroutine fails, all sibling coroutines are cancelled immediately.

B To allow child coroutines to fail independently without cancelling their siblings or the parent scope.

C To automatically restart failed child coroutines without manual intervention.

D To run all child coroutines sequentially instead of concurrently.

💡 Hint

Think about failure isolation between child coroutines.

SupervisorJob is designed so that failure in one child coroutine does not affect others or the parent scope, allowing independent failure handling.

🔧 Debug

advanced

Identify the error in this coroutine code using SupervisorJob

This Kotlin code intends to use SupervisorJob to isolate child coroutine failures. What is the error causing the program to not behave as expected?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val supervisor = SupervisorJob()
    val scope = CoroutineScope(coroutineContext + supervisor)

    val child1 = scope.launch {
        delay(100)
        println("Child 1 done")
    }

    val child2 = scope.launch {
        delay(50)
        throw Exception("Child 2 error")
    }

    child1.join()
    child2.join()
    println("Done")
}

A The CoroutineScope is missing the coroutineContext, so SupervisorJob is not combined with Dispatchers, causing unexpected behavior.

B SupervisorJob should be replaced with Job to isolate failures properly.

C The child coroutines are not launched with async, so exceptions are not caught.

D The delay times cause child1 to finish before child2 throws an exception, so no error is observed.

💡 Hint

Check how CoroutineScope is created with context elements.

CoroutineScope should combine SupervisorJob with the existing coroutineContext (like Dispatchers) to work properly. Using only SupervisorJob loses dispatcher context, causing unexpected behavior.

❓ Predict Output

advanced

What happens to the parent scope when a child coroutine fails with SupervisorJob?

Given this Kotlin code, what will be the output and state of the parent scope after child2 fails?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val supervisor = SupervisorJob()
    val scope = CoroutineScope(coroutineContext + supervisor)

    val child1 = scope.launch {
        delay(100)
        println("Child 1 finished")
    }

    val child2 = scope.launch {
        delay(50)
        throw IllegalStateException("Child 2 failed")
    }

    try {
        child2.join()
    } catch (e: Exception) {
        println("Caught exception: ${e.message}")
    }

    println("Parent scope active: ${scope.isActive}")
    child1.join()
}

A

Caught exception: Child 2 failed
Parent scope active: true
Child 1 finished

B

Caught exception: Child 2 failed
Parent scope active: false
Child 1 finished

C

No exception caught
Parent scope active: false
Child 1 finished

D

No exception caught
Parent scope active: true
Child 1 finished

💡 Hint

SupervisorJob prevents parent cancellation on child failure.

The exception from child2 is caught, the parent scope remains active, and child1 completes successfully.

🧠 Conceptual

expert

How does SupervisorJob affect exception propagation in Kotlin coroutines?

Which statement best describes how SupervisorJob changes exception propagation compared to a regular Job in Kotlin coroutines?

A SupervisorJob propagates exceptions from any child coroutine to the parent immediately, cancelling all siblings.

B SupervisorJob suppresses all exceptions from child coroutines, so the parent never sees any failures.

C SupervisorJob allows child coroutines to fail independently; exceptions do not cancel siblings or the parent, but are still propagated to the parent’s handler if unhandled.

D SupervisorJob queues exceptions from child coroutines and throws them only after all children complete.

💡 Hint

Think about failure isolation and exception visibility.

SupervisorJob isolates failures so siblings and parent are not cancelled, but exceptions still propagate to the parent’s CoroutineExceptionHandler if unhandled.