Kotlin withContext vs Async-await

In this blog, we are going to learn about the withContext and Async-await in Kotlin. We will also see how the withContext and Async-await differ from each other and when to use which one.
I will be using this project for the implementation part. If you have not gone through the project, you should go through and then come back. The project follows a basic MVVM Architecture for simplicity. You can find the complete code for the implementation mentioned in this blog in the project itself.
Let's get started.
Suppose we have two long-running tasks like below:
private suspend fun doLongRunningTaskOne(): String {
delay(5000)
return "One"
}
private suspend fun doLongRunningTaskTwo(): String {
delay(5000)
return "Two"
}
And now, we can run the two tasks in parallel by using the async-await
like below:
fun startLongRunningTaskInParallel() {
viewModelScope.launch {
val resultOneDeferred = async { doLongRunningTaskOne() }
val resultTwoDeferred = async { doLongRunningTaskTwo() }
val combinedResult = resultOneDeferred.await() + resultTwoDeferred.await()
}
}
Here if you notice, we have used the
which returns an instance of async{}
, which has an Deferred<T>
function that returns the result of the coroutine like we have future in Java in which we do await()
to the get the result.future.get()
Now, let's see what happens if we use withContext
instead of the async-await
.
fun startLongRunningTaskInParallel() {
viewModelScope.launch {
val resultOne = withContext(Dispatchers.IO) { doLongRunningTaskOne() }
val resultTwo = withContext(Dispatchers.IO) { doLongRunningTaskTwo() }
val combinedResult = resultOne + resultTwo
}
}
When we use
, it will run the tasks in series instead of parallel.withContext
This is the major difference between the withContext and async-await.
So, when we have a single task to run in the background thread. We should use the withContext. For example like below:
private suspend fun doLongRunningTask() {
withContext(Dispatchers.Default) {
// your code for doing a long running task
// Added delay to simulate
delay(5000)
}
}
Then start it.
fun startLongRunningTask() {
viewModelScope.launch {
doLongRunningTask()
}
}
This way, we can use the withContext.
The thumb-rules:
- Use
when you do not need the parallel execution.withContext
- Use
only when you need the parallel execution.async
- Both
andwithContext
can be used to get the result which is not possible with theasync
.launch
- Use
to return the result of a single task.withContext
- Use
for results from multiple tasks that run in parallel.async
Now, we know how the withContext
and async-await
differ from each other and when to use which one.
You can find the end to end implementation in this project.
That's it for now.
Learn System Design for your next Interview from here.
Also, Let’s become friends on Twitter, Linkedin, Github, Quora, and Facebook.