SupervisorJob for independent failure in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is SupervisorJob in Kotlin coroutines?

SupervisorJob is a special kind of job that allows child coroutines to fail independently without cancelling their siblings.

beginner

How does SupervisorJob differ from a regular Job in Kotlin?

In a regular Job, if one child coroutine fails, all siblings are cancelled. With SupervisorJob, one child's failure does not affect others.

beginner

Why use SupervisorJob in a coroutine scope?

Use SupervisorJob when you want child coroutines to run independently so that failure in one does not stop others from running.

intermediate

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

The parent coroutine does not get cancelled automatically when a child fails under SupervisorJob. It continues running.

intermediate

Show a simple Kotlin example using SupervisorJob where one child fails but others continue.

val supervisor = SupervisorJob()
val scope = CoroutineScope(Dispatchers.Default + supervisor)

scope.launch {
  delay(100)
  throw Exception("Child 1 failed")
}
scope.launch {
  delay(200)
  println("Child 2 completed")
}

Output:
Child 2 completed

What does SupervisorJob allow in Kotlin coroutines?

A Child coroutines fail independently without cancelling siblings

B All child coroutines cancel together on any failure

C It cancels the parent coroutine on any child failure

D It prevents any coroutine from failing

SupervisorJob allows child coroutines to fail independently without cancelling their siblings.

If a child coroutine fails under a regular Job, what happens?

A Only the failed child is cancelled

B Nothing happens

C The parent coroutine continues unaffected

D All sibling coroutines are cancelled

Under a regular Job, failure in one child cancels all siblings.

Which of these is true about SupervisorJob?

A It cancels the parent on child failure

B It allows siblings to continue after a child failure

C It prevents any coroutine from starting

D It is the default job for all coroutines

SupervisorJob allows siblings to continue running even if one child fails.

How do you create a coroutine scope with SupervisorJob?

A CoroutineScope(Dispatchers.Default + Job())

B CoroutineScope(Dispatchers.Default)

C CoroutineScope(Dispatchers.Default + SupervisorJob())

D CoroutineScope(SupervisorJob())

You combine a dispatcher with SupervisorJob() to create the scope.

What will be printed in this code?

val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())
scope.launch { throw Exception("Fail") }
scope.launch { println("Hello") }

A Hello

B Nothing, all coroutines cancelled

C Exception message printed

D Hello and Exception message printed

With SupervisorJob, the second child prints "Hello" despite the first child's failure.

Explain how SupervisorJob helps manage failures in child coroutines.

Think about what happens when one child fails but others keep working.

Describe how to create a coroutine scope that uses SupervisorJob and why you would do that.

Focus on the syntax and the benefit of independent failure.

Practice

1. What is the main purpose of SupervisorJob in Kotlin coroutines?

easy

A. To cancel all child coroutines when one fails

B. To allow child coroutines to fail independently without cancelling siblings

C. To delay coroutine execution until all children complete

D. To automatically restart failed coroutines

Solution

1. Step 1: Understand SupervisorJob behavior

   SupervisorJob lets child coroutines run independently so one failure doesn't affect others.

2. Step 2: Compare with regular Job

   Regular Job cancels all children if one fails, but SupervisorJob prevents this.

3. Final Answer:

   To allow child coroutines to fail independently without cancelling siblings -> Option B

4. Quick Check:

   SupervisorJob = independent failure [OK]

Hint: Remember: SupervisorJob isolates failures among children [OK]

Common Mistakes:

• Thinking SupervisorJob cancels all children on failure
• Confusing SupervisorJob with CoroutineScope
• Assuming SupervisorJob restarts failed coroutines

2. Which of the following is the correct way to create a CoroutineScope with a SupervisorJob?

easy

A. val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)

B. val scope = CoroutineScope(SupervisorJob)

C. val scope = CoroutineScope(Job() + Dispatchers.Default)

D. val scope = CoroutineScope(Dispatchers.Default)

Solution

1. Step 1: Identify correct SupervisorJob usage

   Creating a scope with SupervisorJob() instance plus a dispatcher is correct syntax.

2. Step 2: Check options for syntax correctness

   val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default) uses SupervisorJob() constructor and adds dispatcher, which is valid.

3. Final Answer:

   val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default) -> Option A

4. Quick Check:

   SupervisorJob() + Dispatcher = correct scope [OK]

Hint: Use SupervisorJob() with + operator to add dispatcher [OK]

Common Mistakes:

• Using SupervisorJob without parentheses
• Not adding a dispatcher to CoroutineScope
• Using Job() instead of SupervisorJob()

3. Consider this Kotlin code snippet using SupervisorJob:

val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
scope.launch {
  launch { throw Exception("Child 1 failed") }
  launch { delay(100); println("Child 2 completed") }
}

What will be printed when this code runs?

medium

A. Child 2 completed

B. Child 1 failed

C. Exception thrown and program crashes

D. No output, both coroutines are cancelled

Solution

1. Step 1: Analyze SupervisorJob effect on children

   With SupervisorJob, failure in one child does not cancel siblings.

2. Step 2: Trace coroutine execution

   Child 1 throws exception immediately, but Child 2 delays and then prints "Child 2 completed".

3. Final Answer:

   Child 2 completed -> Option A

4. Quick Check:

   SupervisorJob allows sibling to finish [OK]

Hint: Child failure won't cancel siblings with SupervisorJob [OK]

Common Mistakes:

• Assuming all children cancel on one failure
• Expecting no output due to exception
• Confusing exception print with println output

4. Identify the error in this Kotlin coroutine code using SupervisorJob:

val scope = CoroutineScope(SupervisorJob)
scope.launch {
  launch { throw Exception("Error") }
  launch { println("Running") }
}

medium

A. launch cannot be called inside another launch

B. Child coroutines cannot throw exceptions

C. CoroutineScope cannot be created without a dispatcher

D. SupervisorJob is used without parentheses, causing a syntax error

Solution

1. Step 1: Check SupervisorJob usage

   SupervisorJob is a function and must be called with parentheses SupervisorJob().

2. Step 2: Validate CoroutineScope creation

   Using SupervisorJob without parentheses is a syntax error; it must be an instance.

3. Final Answer:

   SupervisorJob is used without parentheses, causing a syntax error -> Option D

4. Quick Check:

   SupervisorJob() requires parentheses [OK]

Hint: Always call SupervisorJob() with parentheses [OK]

Common Mistakes:

• Omitting parentheses on SupervisorJob
• Thinking nested launch is invalid
• Assuming dispatcher is mandatory (optional)

5. You want to launch three child coroutines where failure of one should NOT cancel the others. Which setup correctly achieves this using SupervisorJob and handles exceptions independently?

hard

A. Use CoroutineScope(SupervisorJob()) but do not handle exceptions in children

B. Use CoroutineScope(Job()) and rely on default cancellation

C. Use CoroutineScope(SupervisorJob()) and wrap each child launch in try-catch blocks

D. Use GlobalScope without SupervisorJob

Solution

1. Step 1: Choose SupervisorJob for independent failure

   Using SupervisorJob() allows children to fail independently without cancelling siblings.

2. Step 2: Handle exceptions in each child

   Wrapping each child launch in try-catch blocks ensures exceptions are caught and handled independently within each coroutine.

3. Final Answer:

   Use CoroutineScope(SupervisorJob()) and wrap each child launch in try-catch blocks -> Option C

4. Quick Check:

   SupervisorJob + try-catch = safe independent children [OK]

Hint: Combine SupervisorJob with try-catch in children [OK]

Common Mistakes:

• Ignoring exception handling in children
• Using Job() which cancels siblings on failure
• Using GlobalScope without SupervisorJob