SupervisorJob for independent failure in Kotlin - Step-by-Step Execution

Concept Flow - SupervisorJob for independent failure

Start SupervisorJob

↓

Launch Child 1

↓

Launch Child 2

↓

Child 1 Fails?

Yes→Child 2 continues

↓

Child 2 completes

↓

SupervisorJob completes

↓

Parent Coroutine completes

SupervisorJob lets child coroutines fail independently without cancelling siblings or the parent.

Execution Sample

Kotlin

val supervisor = SupervisorJob()
val scope = CoroutineScope(supervisor)
scope.launch { throw Exception("Fail 1") }
scope.launch { delay(100); println("Child 2 done") }

Two child coroutines run under SupervisorJob; one fails, the other completes normally.

Execution Table

Step	Action	Child 1 State	Child 2 State	SupervisorJob State	Output
1	Start SupervisorJob and CoroutineScope	Not started	Not started	Active
2	Launch Child 1	Running	Not started	Active
3	Launch Child 2	Running	Running	Active
4	Child 1 throws Exception	Failed	Running	Active	Exception("Fail 1") thrown
5	Child 2 continues after delay	Failed	Running	Active
6	Child 2 prints message	Failed	Completed	Active	Child 2 done
7	SupervisorJob completes after children finish	Failed	Completed	Completed
8	Parent CoroutineScope completes	Failed	Completed	Completed

💡 Child 1 failure does not cancel Child 2 or SupervisorJob; all complete independently.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 6	Final
Child 1 State	Not started	Running	Running	Failed	Failed	Failed
Child 2 State	Not started	Not started	Running	Running	Completed	Completed
SupervisorJob State	Active	Active	Active	Active	Active	Completed

Key Moments - 2 Insights

Why does Child 2 keep running even though Child 1 failed?

Because SupervisorJob isolates failures; as shown in step 4 and 5 of execution_table, Child 1 fails but SupervisorJob stays active and Child 2 continues.

Does the failure of Child 1 cancel the SupervisorJob?

No, SupervisorJob remains active until all children complete, as seen in step 7 where SupervisorJob completes only after Child 2 finishes.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of Child 1 at step 5?

A Running

B Failed

C Completed

D Not started

💡 Hint

Check the 'Child 1 State' column at step 5 in execution_table.

At which step does Child 2 print its message?

A Step 4

B Step 5

C Step 6

D Step 7

💡 Hint

Look for the 'Output' column mentioning 'Child 2 done' in execution_table.

If SupervisorJob was replaced with a regular Job, what would happen after Child 1 fails?

A SupervisorJob cancels Child 2

B Parent CoroutineScope completes immediately

C Child 2 continues running

D Nothing changes

💡 Hint

Recall SupervisorJob isolates failures; a regular Job cancels siblings on failure.

Concept Snapshot

SupervisorJob lets child coroutines fail independently.
Failure in one child does NOT cancel siblings or the parent.
Use CoroutineScope(SupervisorJob()) to isolate failures.
Child coroutines run concurrently; failures are isolated.
SupervisorJob completes only after all children finish.

Full Transcript

This visual trace shows how SupervisorJob manages child coroutine failures independently. We start a SupervisorJob and launch two child coroutines. Child 1 throws an exception and fails, but Child 2 continues running and completes successfully. The SupervisorJob remains active until all children finish, then completes. This means failure in one child does not cancel others or the parent scope. The variable tracker confirms the states of children and SupervisorJob at each step. Key moments clarify why Child 2 is unaffected by Child 1's failure. The quiz tests understanding of states and SupervisorJob behavior. This helps beginners see how SupervisorJob isolates failures in Kotlin coroutines.

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