GlobalScope vs CoroutineScope vs lifecycleScope
First, let's start with definitions to make it clear. If you need a tutorial or playground for Coroutines and Coroutines Flow you can check out this tutorial/playground i created.
Scope
is object you use to launch coroutines that only contains one object which is CoroutineContext
public interface CoroutineScope { /** * The context of this scope. * Context is encapsulated by the scope and used for implementation of coroutine builders that are extensions on the scope. * Accessing this property in general code is not recommended for any purposes except accessing the [Job] instance for advanced usages. * * By convention, should contain an instance of a [job][Job] to enforce structured concurrency. */ public val coroutineContext: CoroutineContext}
The coroutine context is a set of rules and configurations that definehow the coroutine will be executed.Under the hood, it’s a kind of map, with a set of possible keys and values.
Coroutine context is immutable, but you can add elements to a context using plus operator,just like you add elements to a set, producing a new context instance
The set of elements that define the behavior of a coroutine are:
- CoroutineDispatcher — dispatches work to the appropriate thread.
- Job — controls the lifecycle of the coroutine.
- CoroutineName — name of the coroutine, useful for debugging.
- CoroutineExceptionHandler — handles uncaught exceptions
DispatchersDispatchers determine which thread pool should be used. Dispatchers class is alsoCoroutineContext which can be added to CoroutineContext
Dispatchers.Default: CPU-intensive work, such as sorting large lists, doing complex calculations and similar. A shared pool of threads on the JVM backs it.
Dispatchers.IO: networking or reading and writing from files.In short – any input and output, as the name states
Dispatchers.Main: mandatory dispatcher for performing UI-related events in Android's main or UI thread.
For example, showing lists in a RecyclerView, updating Views and so on.
You can check out Android's official documents for more info on dispatchers.
Edit Even though official document states thatDispatchers.IO - This dispatcher is optimized to perform disk ornetwork I/O outside of the main thread. Examples include using theRoom component, reading from or writing to files, and running anynetwork operations.
Answer from Marko Topolnic
IO runs the coroutine on a special, flexible thread pool. It existsonly as a workaround when you are forced to use a legacy, blocking IOAPI that would block its calling thread.
might be right either.
Job A coroutine itself is represented by a Job.A Job is a handle to a coroutine. For every coroutine that you create (by launch or async),it returns a Job instance that uniquely identifies the coroutine and manages its lifecycle.You can also pass a Job to a CoroutineScope to keep a handle on its lifecycle.
It is responsible for coroutine’s lifecycle, cancellation, and parent-child relations.A current job can be retrieved from a current coroutine’s context:A Job can go through a set of states: New, Active, Completing, Completed, Cancelling and Cancelled.while we don’t have access to the states themselves,we can access properties of a Job: isActive, isCancelled and isCompleted.
CoroutineScope It is defined a simple factory function that takes CoroutineContext
s as arguments to create wrapper around the combined CoroutineContext as
public fun CoroutineScope(context: CoroutineContext): CoroutineScope = ContextScope(if (context[Job] != null) context else context + Job())internal class ContextScope(context: CoroutineContext) : CoroutineScope { override val coroutineContext: CoroutineContext = context // CoroutineScope is used intentionally for user-friendly representation override fun toString(): String = "CoroutineScope(coroutineContext=$coroutineContext)"}
and creates a Job
element if the provide context does not have one already.
Let's look at GlobalScope source code
/** * A global [CoroutineScope] not bound to any job. * * Global scope is used to launch top-level coroutines which are operating on the whole application lifetime * and are not cancelled prematurely. * Another use of the global scope is operators running in [Dispatchers.Unconfined], which don't have any job associated with them. * * Application code usually should use an application-defined [CoroutineScope]. Using * [async][CoroutineScope.async] or [launch][CoroutineScope.launch] * on the instance of [GlobalScope] is highly discouraged. * * Usage of this interface may look like this: * * ``` * fun ReceiveChannel<Int>.sqrt(): ReceiveChannel<Double> = GlobalScope.produce(Dispatchers.Unconfined) { * for (number in this) { * send(Math.sqrt(number)) * } * } * ``` */public object GlobalScope : CoroutineScope { /** * Returns [EmptyCoroutineContext]. */ override val coroutineContext: CoroutineContext get() = EmptyCoroutineContext}
As you can see it extends CoroutineScope
1- GlobalScope.launch(Dispatchers.IO) {}
GlobalScope is alive as long as you app is alive, if you doing some counting for instance in this scope and rotate your device it will continue the task/process.
GlobalScope.launch(Dispatchers.IO) {}
runs as long as your app is alive but in IO thread because of using Dispatchers.IO
2- GlobalScope.launch{}
It's same as the first one but by default, if you don't have any context, launch uses EmptyCoroutineContext which uses Dispatchers.Default, so only difference is thread with first one.
3- CoroutineScope(Dispatchers.IO).launch{}
This one is the same as first one with only syntax difference.
4- lifecycleScope.launch(Dispatchers.IO){}
lifecycleScope
is an extention for LifeCycleOwner
and bound to Actvity or Fragment's lifCycle where scope is canceled when that Activity or Fragment is destroyed.
/** * [CoroutineScope] tied to this [LifecycleOwner]'s [Lifecycle]. * * This scope will be cancelled when the [Lifecycle] is destroyed. * * This scope is bound to * [Dispatchers.Main.immediate][kotlinx.coroutines.MainCoroutineDispatcher.immediate]. */val LifecycleOwner.lifecycleScope: LifecycleCoroutineScope get() = lifecycle.coroutineScope
You can also use this as
class Activity3CoroutineLifecycle : AppCompatActivity(), CoroutineScope { private lateinit var job: Job override val coroutineContext: CoroutineContext get() = job + Dispatchers.Main + CoroutineName("🙄 Activity Scope") + CoroutineExceptionHandler { coroutineContext, throwable -> println("🤬 Exception $throwable in context:$coroutineContext") } private val dataBinding by lazy { Activity3CoroutineLifecycleBinding.inflate(layoutInflater) } override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(dataBinding.root) job = Job() dataBinding. button.setOnClickListener { // This scope lives as long as Application is alive GlobalScope.launch { for (i in 0..300) { println("🤪 Global Progress: $i in thread: ${Thread.currentThread().name}, scope: $this") delay(300) } } // This scope is canceled whenever this Activity's onDestroy method is called launch { for (i in 0..300) { println("😍 Activity Scope Progress: $i in thread: ${Thread.currentThread().name}, scope: $this") withContext(Dispatchers.Main) { dataBinding.tvResult.text = "😍 Activity Scope Progress: $i in thread: ${Thread.currentThread().name}, scope: $this" } delay(300) } } } } override fun onDestroy() { super.onDestroy() job.cancel() }}
TL;DR
GlobalScope.launch(Dispatchers.IO): Launches a top-level coroutine on
Dispatchers.IO
. Coroutine is unbound and keeps running until finished or cancelled. Often discouraged since programmer has to maintain a reference tojoin()
orcancel()
.GlobalScope.launch: Same as above, but
GlobalScope
usesDispatchers.Default
if not specified. Often discouraged.CoroutineScope(Dispatchers.IO).launch: Creates a coroutine scope which uses
Dispatchers.IO
unless a dispatcher is specified in the coroutine builder i.e.launch
CoroutineScope(Dispatchers.IO).launch(Dispatchers.Main): Bonus one. Uses the same coroutine scope as above (if the scope instance is same!) but overrides
Dispatcher.IO
withDispatchers.Main
for this coroutine.lifecycleScope.launch(Dispatchers.IO): Launches a coroutine within the lifecycleScope provided by AndroidX. Coroutine gets cancelled as soon as lifecycle is invalidated (i.e. user navigates away from a fragment). Uses
Dispatchers.IO
as thread pool.lifecycleScope.launch: Same as above, but uses
Dispatchers.Main
if not specified.
Explantion
Coroutine scope promotes structured concurrency, whereby you can launch multiple coroutines in the same scope and cancel the scope (which in turn cancels all the coroutines within that scope) if the need be. On the contrary, a GlobalScope coroutine is akin to a thread, where you need to keep a reference in-order to join()
or cancel()
it. Here's an excellent article by Roman Elizarov on Medium.
CoroutineDispatcher tells the coroutine builder (in our case launch {}
) as to which pool of threads is to be used. There are a few predefined Dispatchers available.
Dispatchers.Default
- Uses a thread pool equivalent to number of CPU cores. Should be used for CPU bound workload.Dispatchers.IO
- Uses a pool of 64 threads. Ideal for IO bound workload, where the thread is usually waiting; maybe for network request or disk read/write.Dispatchers.Main
(Android only): Uses main thread to execute the coroutines. Ideal for updating UI elements.
Example
I've written a small demo fragment with 6 functions corresponding to the above 6 scenarios. If you run the below fragment on an Android device; open the fragment and then leave the fragment; you'll notice that only the GlobalScope coroutines are still alive. Lifecycle coroutines are cancelled by lifecycleScope when the lifecycle is invalid. On the other hand, CoroutineScope ones are cancelled on onPause()
invocation which is explicitly done by us.
class DemoFragment : Fragment() { private val coroutineScope = CoroutineScope(Dispatchers.IO) init { printGlobalScopeWithIO() printGlobalScope() printCoroutineScope() printCoroutineScopeWithMain() printLifecycleScope() printLifecycleScopeWithIO() } override fun onPause() { super.onPause() coroutineScope.cancel() } private fun printGlobalScopeWithIO() = GlobalScope.launch(Dispatchers.IO) { while (isActive) { delay(1000) Log.d("CoroutineDemo", "[GlobalScope-IO] I'm alive on thread ${Thread.currentThread().name}!") } } private fun printGlobalScope() = GlobalScope.launch { while (isActive) { delay(1000) Log.d("CoroutineDemo", "[GlobalScope] I'm alive on ${Thread.currentThread().name}!") } } private fun printCoroutineScope() = coroutineScope.launch { while (isActive) { delay(1000) Log.d("CoroutineDemo", "[CoroutineScope] I'm alive on ${Thread.currentThread().name}!") } Log.d("CoroutineDemo", "[CoroutineScope] I'm exiting!") } private fun printCoroutineScopeWithMain() = coroutineScope.launch(Dispatchers.Main) { while (isActive) { delay(1000) Log.d("CoroutineDemo", "[CoroutineScope-Main] I'm alive on ${Thread.currentThread().name}!") } Log.d("CoroutineDemo", "[CoroutineScope-Main] I'm exiting!") } private fun printLifecycleScopeWithIO() = lifecycleScope.launch(Dispatchers.IO) { while (isActive) { delay(1000) Log.d("CoroutineDemo", "[LifecycleScope-IO] I'm alive on ${Thread.currentThread().name}!") } Log.d("CoroutineDemo", "[LifecycleScope-IO] I'm exiting!") } private fun printLifecycleScope() = lifecycleScope.launch { while (isActive) { delay(1000) Log.d("CoroutineDemo", "[LifecycleScope] I'm alive on ${Thread.currentThread().name}!") } Log.d("CoroutineDemo", "[LifecycleScope] I'm exiting!") }}
I'd organize your list along three axes:
GlobalScope
vs.CoroutineScope()
vs.lifecycleScope
Dispatchers.IO
vs. inherited (implicit) dispatcher- Specify the dispatcher in the scope vs. as an argument to
launch
1. Choice of Scope
A big part of Kotlin's take on coroutines is structured concurrency, which means all the coroutines are organized into a hierarchy that follows their dependencies.If you're launching some background work, we assume you expect its results to appear at some point while the current "unit of work" is still active, i.e., the user hasn't navigated away from it and doesn't care anymore about its result.
On Android, you have the lifecycleScope
at your disposal that automatically follows the user's navigation across UI activities, so you should use it as the parent of background work whose results will become visible to the user.
You may also have some fire-and-forget work, that you just need to finish eventually but the user doesn't await its result. For this you should use Android's WorkManager
or similar features that can safely go on even if the user switches to another application. These are usually tasks that synchronize your local state with the state kept on the server side.
In this picture, GlobalScope
is basically an escape hatch from structured concurrency. It allows you to satisfy the form of supplying a scope, but defeats all the mechanisms it's supposed to implement. GlobalScope
can never be cancelled and it has no parent.
Writing CoroutineScope(...).launch
is just wrong because you create a scope object without a parent that you immediately forget, and thus have no way of cancelling it. It's similar to using GlobalScope
but even more hacky.
2. Choice of Dispatcher
The coroutine dispatcher decides which threads your coroutine may run on. On Android, there are three dispatchers you should care about:
Main
runs everything on the single GUI thread. It should be your main choice.IO
runs the coroutine on a special, flexible thread pool. It exists only as a workaround when you are forced to use a legacy, blocking IO API that would block its calling thread.Default
also uses a thread pool, but of fixed size, equal to the number of CPU cores. Use it for computation-intensive work that would take long enough to cause a glitch in the GUI (for example, image compression/decompression).
3. Where to Specify the Dispatcher
First, you should be aware of the dispatcher specified in the coroutine scope you're using. GlobalScope
doesn't specify any, so the general default is in effect, the Default
dispatcher. lifecycleScope
specifies the Main
dispatcher.
We already explained that you shouldn't create ad-hoc scopes using the CoroutineScope
constructor, so the proper place to specify an explicit dispatcher is as a parameter to launch
.
In technical detail, when you write someScope.launch(someDispatcher)
, the someDispatcher
argument is actually a full-fledged coroutine context object which happens to have a single element, the dispatcher. The coroutine you're launching creates a new context for itself by combining the one in the coroutine scope and the one you supply as a parameter. On top of that, it creates a fresh Job
for itself and adds it to the context. The job is a child of the one inherited in the context.