SupervisorJob for independent failure in Kotlin - Mini Project: Build & Apply

SupervisorJob for independent failure

📖 Scenario: You are building a Kotlin program that launches two independent tasks using coroutines. You want to make sure that if one task fails, the other task continues running without being cancelled.

🎯 Goal: Create a Kotlin program that uses SupervisorJob to launch two coroutines. One coroutine will throw an exception, and the other will complete successfully. The program should show that the failure of one coroutine does not cancel the other.

📋 What You'll Learn

Create a SupervisorJob instance called supervisor

Create a CoroutineScope called scope using supervisor

Launch two coroutines inside scope named job1 and job2

job1 should throw an exception after a short delay

job2 should print a success message after a longer delay

Use join() to wait for both coroutines to finish

Print messages to show the independent failure behavior

💡 Why This Matters

🌍 Real World

In real apps, you often want some tasks to continue even if others fail, like loading multiple independent data sources.

💼 Career

Understanding <code>SupervisorJob</code> is important for Kotlin developers working with coroutines to build resilient and fault-tolerant applications.

1

Create a SupervisorJob and CoroutineScope

Create a val supervisor and set it to SupervisorJob(). Then create a val scope and set it to CoroutineScope(supervisor + Dispatchers.Default).

Kotlin

# Create a val supervisor and set it to SupervisorJob()
# Create a val scope and set it to CoroutineScope(supervisor + Dispatchers.Default)

Hint

Use SupervisorJob() to create the supervisor job. Combine it with Dispatchers.Default to create the scope.

2

Launch two coroutines with independent behavior

Inside scope, launch two coroutines called job1 and job2. In job1, delay 100 ms then throw an exception with throw RuntimeException("Failure in job1"). In job2, delay 300 ms then print "Job2 completed successfully".

Kotlin

import kotlinx.coroutines.*

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

// Launch job1 and job2 inside scope
// job1 throws exception after 100 ms
// job2 prints success after 300 ms
# Your code here

Hint

Use scope.launch { ... } to start each coroutine. Use delay() to wait before throwing or printing.

3

Wait for both coroutines to finish

Use job1.join() and job2.join() to wait for both coroutines to complete.

Kotlin

import kotlinx.coroutines.*

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

val job1 = scope.launch {
    delay(100)
    throw RuntimeException("Failure in job1")
}

val job2 = scope.launch {
    delay(300)
    println("Job2 completed successfully")
}

// Wait for job1 and job2 to finish
# Your code here

Hint

Use runBlocking { ... } to wait for the coroutines. Use try-catch around job1.join() to catch the exception.

4

Print final message showing independent failure

After waiting for both jobs, print "Program completed: job1 failed but job2 succeeded" to show that the failure of job1 did not cancel job2.

Kotlin

import kotlinx.coroutines.*

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

val job1 = scope.launch {
    delay(100)
    throw RuntimeException("Failure in job1")
}

val job2 = scope.launch {
    delay(300)
    println("Job2 completed successfully")
}

runBlocking {
    try {
        job1.join()
    } catch (e: Exception) {
        println("Caught exception from job1: ${e.message}")
    }
    job2.join()
}

// Print final message
# Your code here

Hint

Use println() to print the final message after both jobs finish.

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