Kotlin Coroutine Job Lifecycle
How manage the Lifecycle of a Coroutine Job
I have just written an article about Kotlin Coroutines but now I want to go deep the topic of Coroutine Scope. What’s its lifecycle and the behavior of jobs.
How use and test Kotlin Coroutines with Mockk library
Create and test a Kotlin Coroutine inside an Android Project with ViewModel
The CoroutineScope and the Inheritance
When we launch a coroutine we need a Context to run it: a CoroutineScope. This one works like a RXJava Scheduler but it has many other features defined by four parameters listed below:
- Coroutine Dispatcher: it works like a Thread Pool, by default Dispatchers.Default
- Coroutine Name: the name of coroutine (used for debugging)
- Parent Job: the parent Job of children jobs, by default is null
- Coroutine Exception Handler: the callback to handle coroutine exception inside the job
so to create a CoroutineScope is quite simple:
Inside the launch method we have a Coroutine Context inherited by the CoroutineScope where the parent Job assumed the value of job value returned by launch method. The scheme below explains the inheritance.
This concept is important because explain how jobs are managed inside the coroutines and how they work inside the inheritance of cancellation.
Coroutine Parent Job Behavior and Cancellation
From the previous example we can write two different examples of job cancellation:
In the first case we have a coroutineScope and two child jobs, if we will try to cancel the first one the result will be:
Job 1 state: Cancelled
Job 2 state: Complete
Parent job is active: true
we can see the first job is cancelled but the parent is active, this because the cancellation of a job not influence others.
From this example is interesting analyze the second one:
with its output:
Job 1 state: cancelled
Job 2 state: cancelled
Parent job is active: false
the result is different, we can see two jobs have a cancelled state, this because if the parent job is cancelled its state is propagated to all child jobs.
This is very useful because with a use case where we want to kill all suspend functions linked to the parent we don’t need to cancel separately, we can stop all in one line.
You can see the pattern implementation with Android inside an Android ViewModel:
The onCleared() method is called from the Android API when an Activity is killed from the Android Lifecycle, overwriting this method we can implement the parent job cancelling.
Coroutines Job States
We have said when we launch a coroutine the invoke return a job object, with this we are able to manage the thread and to suspend it if necessary. In this way we change the Job status, but what are the possible status?
When the execution of a coroutine doesn’t generate Exception it ends with the completed state, instead it ends with cancelled state during exception of cancel by the user.
The last important thing about CoroutineScope is if it has “cancelled” state it can’t be used anymore. If you try to use a CoroutineScope in cancelled state new jobs will inheritate the cancelled state too and will not execute the body of the function.
Thanks for reading
I hope I helped you with this article, if you have other questions, please let me know! If you have liked this article don’t forget to 👏it. Thanks!