Coroutines are a concurrency design pattern used in programming to write asynchronous code in a more sequential and readable manner. Both suspending and blocking play a role in managing the flow of asynchronous code.
Suspending
In coroutine terminology, Suspending functions are functions that can suspend a coroutine. When a coroutine encounters a suspending function, it can voluntarily suspend its execution without blocking the underlying thread. This allows other coroutines to continue running in the meantime. Suspending functions are marked with the suspend
keyword.
The suspension doesn't necessarily mean the entire thread is blocked; it simply allows the coroutine to release the thread and let other tasks run.
Blocking
"Blocking" refers to the act of stopping the execution of a thread until a certain operation completes. When a thread is blocked, it is essentially waiting for some resource or operation to finish, and it cannot do anything else during that time.
In contrast to suspending, blocking operations can be less efficient in terms of resource utilization because a blocked thread is not available to perform other tasks.
Traditional synchronous code often involves blocking operations, where the program waits for an I/O operation, database query, or other time-consuming tasks to complete before moving on.
An example with runBlocking and coroutineScope
runBlocking
and coroutineScope
builders may look similar because they both wait for their body and all its children to complete. The main difference is that the runBlocking
method blocks the current thread for waiting, while coroutineScope
just suspends, releasing the underlying thread for other usages. Because of that difference, runBlocking
is a regular function and coroutineScope
is a suspending function.
coroutineScope
The coroutines initiated through coroutineScope
exhibit suspendable behavior. To illustrate this concept, we'll initiate a coroutine dispatcher using a fixed thread pool with two threads as our execution context:
val dispatcher = Executors.newFixedThreadPool(2).asCoroutineDispatcher()
Now, let's create a function that launches ten coroutines. Each coroutine, in turn, initiates a child coroutine using coroutineScope
:
fun exampleCoroutineScope() = runBlocking {
(1..10).forEach {
launch(dispatcher) {
coroutineScope {
println("Coroutine $it started on thread: ${Thread.currentThread().name}")
delay(500)
println("Coroutine $it completed on thread: ${Thread.currentThread().name}")
}
}
}
}
Here, we encapsulate our logic within runBlocking
to seamlessly integrate with our blocking code. Within this block, we utilize launch
to dispatch suspendable coroutines to any inactive thread in the context's thread pool.
Additionally, coroutineScope
is employed to initiate a coroutine that invokes delay()
with a 500-millisecond duration. The delay()
function is a suspension point for the coroutine launched by coroutineScope
.
Let's execute this function to observe Kotlin's ability to suspend these coroutines:
fun main() {
val timeInMills = measureTimeMillis {
exampleCoroutineScope()
}
println("Time : $timeInMills")
}
Here is the output :
Coroutine 1 started on thread: pool-1-thread-1
Coroutine 2 started on thread: pool-1-thread-2
Coroutine 3 started on thread: pool-1-thread-1
Coroutine 4 started on thread: pool-1-thread-1
Coroutine 5 started on thread: pool-1-thread-1
Coroutine 6 started on thread: pool-1-thread-1
Coroutine 7 started on thread: pool-1-thread-1
Coroutine 8 started on thread: pool-1-thread-1
Coroutine 9 started on thread: pool-1-thread-1
Coroutine 10 started on thread: pool-1-thread-1
Coroutine 2 completed on thread: pool-1-thread-1
Coroutine 1 completed on thread: pool-1-thread-2
Coroutine 3 completed on thread: pool-1-thread-1
Coroutine 4 completed on thread: pool-1-thread-2
Coroutine 5 completed on thread: pool-1-thread-1
Coroutine 6 completed on thread: pool-1-thread-2
Coroutine 7 completed on thread: pool-1-thread-2
Coroutine 8 completed on thread: pool-1-thread-1
Coroutine 9 completed on thread: pool-1-thread-1
Coroutine 10 completed on thread: pool-1-thread-2
Time : 633
The suspension mechanism ensures that a suspended coroutine does not hinder any threads, allowing another coroutine to seamlessly take advantage of the thread and each coroutine can efficiently resume its execution on any available thread within the pool.
runBlocking
fun exampleRunBlocking() = runBlocking {
(1..10).forEach {
launch(context) {
runBlocking {
println("runBlocking $it started on ${Thread.currentThread().name}")
delay(500)
println("runBlocking $it ended on ${Thread.currentThread().name}")
}
}
}
}
Output :
runBlocking 1 started on pool-1-thread-1
runBlocking 2 started on pool-1-thread-2
runBlocking 1 ended on pool-1-thread-1
runBlocking 2 ended on pool-1-thread-2
runBlocking 3 started on pool-1-thread-2
runBlocking 4 started on pool-1-thread-1
runBlocking 3 ended on pool-1-thread-2
runBlocking 4 ended on pool-1-thread-1
runBlocking 5 started on pool-1-thread-2
runBlocking 6 started on pool-1-thread-1
runBlocking 6 ended on pool-1-thread-1
runBlocking 5 ended on pool-1-thread-2
runBlocking 7 started on pool-1-thread-1
runBlocking 8 started on pool-1-thread-2
runBlocking 7 ended on pool-1-thread-1
runBlocking 8 ended on pool-1-thread-2
runBlocking 9 started on pool-1-thread-1
runBlocking 10 started on pool-1-thread-2
runBlocking 9 ended on pool-1-thread-1
runBlocking 10 ended on pool-1-thread-2
Time : 2597
In this scenario, it's observed that each coroutine initiated by runBlocking
completed its execution on the same thread where it started.
This behavior is indicative of the fact that the coroutine launched within runBlocking
did not respond to the suspension point created by the delay()
call. They are not suspendable.
Conclusion
In summary, the key difference lies in how coroutines handle waiting for asynchronous operations. Suspending allows a coroutine to yield control without blocking the underlying thread, enabling better concurrency and resource utilization. Blocking, on the other hand, involves the thread waiting until the operation completes, which can lead to inefficiencies in terms of resource usage. Coroutines are designed to be more efficient by leveraging suspending functions to avoid unnecessary blocking and allow other tasks to proceed in the meantime.