Kotlin Coroutines
Coroutines are nothing but lightweight threads. Coroutines provide us an easy way to do synchronous and asynchronous programming. Coroutines allow execution to be suspended and resumed later at some point in the future which is best suited for performing non-blocking operations in the case of multithreading.
Coroutines is a lightweight thread because creating coroutines doesn't allocate new threads. Instead, they use predefined thread pools, and smart scheduling. Scheduling is the process of determining which piece of work you will execute next.. Is called on suspending functions. We can suspend and resume the Coroutines while execution. This means we can have a long-running task, which can be executed one by one or which can be executed little-by-little.. We can pause it any number of times and resume it when we are ready again.
Advantages/Properties :
- Run 1 background thread & Multiple Coroutines
- Light Weight Threads
- Can run in parallel
- Can wait for each other
- Communicate with each other
- Coroutines != thread
- Threads doesn't have such inbuilt mechanism to cancel itself internally
- Can create 100's of coroutines without any memory issue
- For threads, application waits for the background thread to complete its execution whereas in case of Coroutines the application will not have any idea about coroutines
- If we are calling any coroutine from a fragment or activity using lifecycleScope.launch(), whenever the activity or fragment is destroyed, the coroutine also gets destroyed
- Lower chances for memory leaks
- Built-in cancellation support
- Jetpack libraries provide coroutines support
Coroutine Scope
A CoroutineScope keeps track of any coroutine it creates using the builder functions launch or async. It provides the ability to cancel a coroutine at any point in time. The scope is nothing but a lifespan. A coroutine cannot be launched without scope. CoroutineScope gets notified whenever a failure happens. CoroutineScope takes CoroutineContext as an argument. A CoroutineScope keeps track of any coroutine it creates using the builder functions launch or async. It provides the ability to cancel a coroutine at any point in time. The scope is nothing but a lifespan. A coroutine cannot be launched without scope. CoroutineScope gets notified whenever a failure happens. CoroutineScope takes CoroutineContext as an argument.
- LifecycleScope : This makes sure that all the coroutines running in that particular activity/fragment are destroyed when that particular activity/fragment is destroyed
- ViewModelScope : It will keep the coroutine alive as long as the ViewModel is alive
- GlobalScope : Lifecycle of this scope is equal to the lifecycle of the entire application and causes memory leaks. To be used only while debugging and not in production applications. GlobalScope.launch { }
- Use Dispatchers ie GlobalScope.launch(Dispatchers.Main) { } to make Main Safe
- We should always create a scope which automatically gets destroyed whenever its not needed so that it wont cause any memory leak ie. viewLifecycleOwner.lifecycleScope.launch { //suspending function }
CoroutineContext
A function that may be started, halted, then resumed is known as a suspend function. One of the most important things to remember about the suspend functions is that they can only be invoked from another suspend function or from a coroutine. Suspending functions are merely standard Kotlin functions with the suspend modifier added, indicating that they can suspend coroutine execution without blocking the current thread. This means that the code you're looking at may pause execution when it calls a suspending function and restart execution at a later time.
Suspending functions can call any other ordinary functions, but another suspending function is required to suspend the execution. Because a suspending function cannot be called from a regular function, numerous coroutine builders are supplied, allowing you to call a suspending function from a non-suspending scope like launch, async, or runBlocking.
delay() function is an example of suspend function
runBlocking {
delay(1000)
}
Job
A Job is a handle to a coroutine. A job is a cancellable thing with a life cycle that ends on its completion or cancellation or failure.
Each coroutine that we create with launch or async returns a Job object that uniquely identifies the coroutine and manages its lifecycle. If we use a normal Job instance when there was an exception in any child other than CancellationException it cancels the parent as well as other children.
The statement job.cancel() just cancels the coroutine started above, this doesn’t affect the scope.
A job is in the active state while the coroutine is working or until the job is completed, or until it fails or canceled.
Why launch is called fire and forget ??
The launch coroutine builder does a fire and forget, it does not return any result to the caller asides the job instance which is just a handle to the background operation.
It inherits the context and job from the scope where it was called but these can be overridden
Fire and forget means it won't return the result to the caller. The coroutineScope builder will suspend itself until all coroutines started inside of it are complete
val TAG = "MainActivity"Using Async and Await:
val job = GlobalScope.launch(Dispatchers.IO) {
val time = measureTimeMillis {
var result1 : String? = null
var result2 : String? = null
val job1 = launch { result1 = networkCall1() }
val job2 = launch { result2 = networkCall2() }
job1.join()
job2.join()
Log.d(TAG, "Answer1 is $result1")
Log.d(TAG, "Answer2 is $result2")
}
Log.d(TAG, "Time taken $time")
}
The async call will return a Deferred result. The deferred type depends on what the async block is returning. If we need to do something asynchronously and need the result of it then we need to make use of it and to get the result we need to call the await() method and this will block the coroutine until the result is available
val TAG = "MainActivity"
val job = GlobalScope.launch(Dispatchers.IO) {
val time = measureTimeMillis {
var result1 = async { networkCall1() }
var result2 = async { networkCall2() }
Log.d(TAG, "Answer1 is ${result1.await()}")
Log.d(TAG, "Answer2 is ${result2.await()}")
}
Log.d(TAG, "Time taken $time")
}
Difference between launch and async
launch / join:-
The launch command is used to start and stop a coroutine. It's as though a new thread has been started. If the code inside the launch throws an exception, it's considered as an uncaught exception in a thread, which is typically written to stderr in backend JVM programs and crashes Android applications. Join is used to wait for the launched coroutine to complete before propagating its exception. A crashed child coroutine, on the other hand, cancels its parent with the matching exception.
async / await:-
The async keyword is used to initiate a coroutine that computes a result. We must use await on the result, which is represented by an instance of Deferred. Uncaught exceptions in async code are held in the resultant Deferred and are not transmitted anywhere else. They are not executed until processed
The launch{} does not return anything and the async{} returns an instance of Deferred, which has an await() function. In other words, we can say that launch is used to fire and forget, and async is used to perform a task and return a result.
launch is used to fire and forget coroutine. It is like starting a new thread. If the code inside the launch terminates with exception, then it is treated like uncaught exception in a thread -- usually printed to stderr in backend JVM applications and crashes Android applications.
join is used to wait for completion of the launched coroutine and it does not propagate its exception. However, a crashed child coroutine cancels its parent with the corresponding exception, too.
async is used to start a coroutine that computes some result. The result is represented by an instance of Deferred and you must use await on it.
An uncaught exception inside the async code is stored inside the resulting Deferred and is not delivered anywhere else, it will get silently dropped unless processed. You MUST NOT forget about the coroutine you’ve started with async.
scope.launch {
try {
doSomething()
} catch(e: Exception) {
// Handle exception logic
}
}However, in the case of async, it’s not the case. It holds the exception until await is invoked. So we can wrap the .await() call inside try/catch
viewModelScope {
val deferredResult = async {
doSomething()
}
try {
deferredResult.await()
} catch(e: Exception) {
// Handle exception thrown
}
}
What are Coroutine Builders?
Coroutine builders are simple extension functions that can create and start a coroutine
Coroutine builders are a way of creating coroutines. Since they are not suspending themselves, they can be called from non-suspending code or any other piece of code. They act as a link between the suspending and non-suspending parts of our code.
The following are three coroutine builders:
1. runBlocking
2. launch
3. async
RunBlocking :
runBlocking blocks the current thread on which it is invoked until the coroutine is completed. It runs the coroutine in the context on the thread it is invoked. It throws InterruptedException If the blocked thread is interrupted
We typically runBlocking to run tests on suspending functions. While running tests, we want to
make sure not to finish the test while we are doing heavy work in test suspend functions.
Launch :
launch is essentially a Kotlin coroutine builder that is “fire and forget”. This means that launch
creates a new coroutine that won’t return any result to the caller. It also allows to start a
coroutine in the background.
The simplest way to create a coroutine is by calling the launch builder on a specified scope. It Launches a new coroutine without blocking the current thread and returns a reference to the coroutine as a Job. The coroutine is canceled when the resulting job is canceled.
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
fun main() {
println("Starting main function..")
GlobalScope.launch {
println(doSomething())
}
runBlocking {
delay(4000L) // make sure to keep the JVM alive in order to wait for doSomething() to execute
}
}
suspend fun doSomething() : String {
delay(3000L) // simulate long running task
return "Did something that was 3 seconds long"
}
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
fun main() {
println("Starting main function..")
GlobalScope.launch {
println(doSomething())
}
runBlocking {
delay(4000L) // make sure to keep the JVM alive in order to wait for doSomething() to execute
}
}
suspend fun doSomething() : String {
delay(3000L) // simulate long running task
return "Did something that was 3 seconds long"
}
In the above code, we call the suspending function, doSomething() and after 3 seconds of delay we print the string: “Did something that is 3 seconds long”.
Note: “delay” in Kotlin, is a suspend function which delays a coroutine without blocking the current thread. It then resumes the coroutine after the specified time (In our case, 3 seconds or 3000 milliseconds).
Async-Await()
Async is a coroutine builder which returns some value to the caller. async can be used to perform an asynchronous task which returns a value. This value in Kotlin terms is a Deferred<T> value.
We can simply use async to create a coroutine doing some heavy work
await() is a suspending function that is called upon the async builder to fetch the value of the Deferred object that is returned. The coroutine started by async will be suspended until the result is ready. When the result is ready, it is returned and the coroutine resumes.
We can’t use async in a normal function as it has to call suspend function await to get the result. So we generally use launch builder inside a normal function and then use async inside it. We need to generally use async only when we need the parallel execution of different tasks as it waits for all the tasks to be completed and returns a deferred result
import kotlinx.coroutines.*
val a = 10
val b = 20
fun main() {
println("Gone to calculate sum of a & b")
GlobalScope.launch {
val result = async {
calculateSum()
}
println("Sum of a & b is: ${result.await()}")
}
println("Carry on with some other task while the coroutine is waiting for a result...")
runBlocking {
delay(3000L) // keeping jvm alive till calculateSum is finished
}
}
suspend fun calculateSum(): Int {
delay(2000L) // simulate long running task
return a + b
}
val a = 10
val b = 20
fun main() {
println("Gone to calculate sum of a & b")
GlobalScope.launch {
val result = async {
calculateSum()
}
println("Sum of a & b is: ${result.await()}")
}
println("Carry on with some other task while the coroutine is waiting for a result...")
runBlocking {
delay(3000L) // keeping jvm alive till calculateSum is finished
}
}
suspend fun calculateSum(): Int {
delay(2000L) // simulate long running task
return a + b
}
Coroutine Builders :
Launch, Async & RunBlocking
launch(local scope) :
Login Operation or logic computation
viewModelScope.launch {
}
GlobalScope.launch{}(Global/Application Level)(Like file download, play music which happens in background)
Not much preferred cos if we miss the reference to it then it will be a problem as it will run in the background and consumes a lot of memory
async(local scope) :
GlobalScope.async{}(Global/Application Level)
runBlocking :
runBlocking{}
Global coroutines are top level coroutines which can survive the entire life of the application
If the runBlocking is running in the main thread or thread T1 then the launch also runs on the same thread and acts as the child coroutine
i.e. it inherits the property of the immediate coroutine and returns a job object
Job Object :
Used to control the coroutine
Launch creates a coroutine that runs on a thread
On the same thread there could be many coroutines that run on the same thread
launch coroutine builder is like fire and forget
when delay function is executed, it suspends the current coroutine and the thread remains free for the time period and can be utilized by other coroutine to run on this thread
It doesn't block the thread on which it operates
It inherits the thread and coroutine scope of the immediate parent coroutine
Returns the job object
controls the coroutine
Async Coroutine Builders
Async doesnt return a job object. It returns a Deffered object which is a Generic type which is a subclass of job object
If we are not returning anything then we can go with deferred.join itself and if we are returning anything then we need to use deferred.await()
val data = deferred.await()
join() and await() are suspending functions. Also the delay function
The main difference between launch and async is that we can return some data and retrieve the same using await method
Async Coroutine Builders launches new coroutine without blocking the current thread and inherits the thread and coroutine scope from immediate parent coroutine
returns a reference to Deferred<T> object
Using deferred object we can either cancel a coroutine or wait for coroutine to finish or retrieve the returned result
runBlocking is generally used to test the suspending functions. It blocks the current thread in which it is operating
Launch and Async coroutines never blocks the thread in which its running
Comments
Post a Comment