SupervisorScope vs. SupervisorJob

 While both are used to handle Structured Concurrency and prevent a single failure from crashing an entire system, they are applied at different levels of the coroutine hierarchy.

1. SupervisorJob

A SupervisorJob is a specific type of Job that you can pass into a CoroutineScope or a coroutine context.

  • Failure Propagation: Normally, if a child coroutine fails, it cancels its parent and all its siblings. A SupervisorJob changes this: a failure of a child does not result in the cancellation of the parent or other siblings.
  • Usage: It is typically used when creating a custom scope (e.g., a background service that manages multiple independent tasks).
  • Key Detail: You must handle exceptions manually (usually via a CoroutineExceptionHandler), or the exception will still reach the thread's uncaught exception handler.

2. SupervisorScope

supervisorScope is a suspending function that creates a new sub-scope with a SupervisorJob.

  • Scope Level: It is used inside an existing coroutine to wrap a block of work.
  • Behavior: It inherits the context from the outer scope but overrides the Job with a SupervisorJob. If any coroutine started inside the supervisorScope fails, the other coroutines inside that same scope continue to run.
  • Completion: The supervisorScope function does not finish until all coroutines launched inside it are complete.

Key Differences

FeatureSupervisorJobsupervisorScope
TypeA property/object (Class instance).A suspending function (Block of code).
PlacementUsually defined in the CoroutineContext.Used inside a coroutine to wrap sub-tasks.
LifecycleStays active until manually cancelled or the scope is destroyed.Ends when all children inside the block finish.
Main Use CaseBuilding a long-lived scope (like viewModelScope).Running multiple independent, temporary tasks.

When to use which?

  • Use SupervisorJob when you are defining a global or long-lived scope where you want the scope to survive even if individual background tasks fail.
  • Use supervisorScope when you have a specific function that needs to run several concurrent tasks, and you don't want one failing task to stop the others in that specific group.

Crucial Warning: If you pass a SupervisorJob() as an argument to launch(SupervisorJob()), it becomes the parent of that coroutine, but it is not linked to the outer scope. This often leads to memory leaks because the new coroutine is no longer a child of the original scope. Use supervisorScope { ... } instead for local tasks.

Comments

Post a Comment

Popular posts from this blog

What is a Coroutine? Why is it better than threads?

Coroutine is a "Lightweight-Thread ". While normal threads are managed by operating system Coroutine is managed by Application Runtime. The word comes from Co-operative + Routine . Unlike threads, which are "pre-emptive" (the OS forces them to stop and start), coroutines cooperate by yielding control when they are waiting for something to finish. I've noted that you'd like me to use Markdown (MD) format for my answers from now on, including support for tags within the Markdown. Why Coroutines are "Better" than Threads ? While threads are powerful, they are expensive. Here is why coroutines are generally preferred for modern, high-concurrency applications: Resource Efficiency (Memory) Threads are heavy. Each thread typically reserves about 1MB of memory for its stack. If you try to launch 100,000 threads on a standard laptop, your system will crash. Coroutines are incredibly tiny. They only require a few kilobytes of memory. You can easily run hundr...
Read more

What are Coroutine Builders?

  In Kotlin,   coroutine builders   are the primary way to create and start a coroutine. They act as the entry point from regular functions into the world of suspension. 1.  launch The  launch  builder is used for  "fire and forget"  tasks. It starts a coroutine that performs work in the background without returning a specific result to the caller. Returns:  A  Job  object (used to cancel the coroutine or check its status). Analogy:  Sending an email; once you hit send, you move on to other tasks. 2.  async The  async  builder is used when you need to  calculate a result  asynchronously. It allows for parallel execution of tasks. Returns:  A  Deferred<T> , which is a non-blocking future. Result:  You must call  .await()  to get the actual value once it is ready. Analogy:  Ordering a pizza; you get a receipt (the  Deferred ) and eventually use it to get your pizza...
Read more

Sealed Classes and Sealed Interfaces

I n Kotlin,   Sealed   classes and interfaces are used to represent   restricted class hierarchies . They allow you to define a fixed set of types, providing more control over inheritance and enabling powerful features like exhaustive   when   expressions. Think of them as "Enums on steroids." While an Enum constant is just a single instance, a subclass of a sealed class can have multiple instances and hold its own unique state. 1. Sealed Class A  sealed class  is an abstract class that can only be subclassed within the same package/module where it is defined. State:  Each subclass can have its own properties and methods. Constructor:  It can have a constructor (private by default) to pass data to subclasses. Usage:  Best used when your types share a common base with some logic or state. 2. Sealed Interface Introduced in Kotlin 1.5,  sealed interface  works exactly like a sealed class but follows interface rules. No State: ...
Read more