Kotlin coroutines provide a powerful way to write asynchronous, non-blocking code that is easy to understand and maintain. Understanding the nuances of sequential and concurrent execution with coroutines is crucial for writing efficient and error-resilient code. In this article, we will explore different ways of invoking suspend functions sequentially and concurrently, and delve into the potential issues and best practices associated with structured concurrency and GlobalScope usage. Let’s dive into the world of asynchronous programming with Kotlin coroutines and unlock the full potential of concurrent computation and parallel processing.

Sequential by default

Let’s assume that we have two suspend functions that do something useful like calling a remote service or doing a computation. But for the sake of this example, we will just add a delay to them.

suspend fun doSomethingUsefulOne(): Int {
    delay(2400)
    return 33
}

suspend fun doSomethingUsefulTwo(resultOne: Int): Int{
    delay(1500)
    return 6
}

Now if we want to use the result of first function in the second function, we would want these functions to be called sequentially. We can do so by just using a normal sequential invocation because the code in a coroutine, just like in regular code, is sequential by default.

fun calculateTimeTaken() = runBlocking {
    val time = measureTimeMillis {
        val one = doSomethingUsefulOne()
        val two = doSomethingUsefulTwo(one)
        println("Final answer is $two")
    }
    println("Completed in $time ms")
}

Concurrent using async

What if there is no dependency between the two functions, we can call the two functions concurrently in order to get faster results. This is where async comes in the picture.

fun calculateTimeTakenInConcurrentCall() = runBlocking {
    val time = measureTimeMillis {
        val one = async { doSomethingUsefulOne() }
        val two = async { doSomethingUsefulTwo() }
        println("Final answer is ${one.await() + two.await()}")
    }
    println("Completed in $time ms")
}

fun calculateTimeTakenInSynchronousLazyCalls() = runBlocking {
    val time = measureTimeMillis {
        val one = async(start = CoroutineStart.LAZY) { doSomethingUsefulOne() }
        val two = async(start = CoroutineStart.LAZY) { doSomethingUsefulTwo() }
        println("Final answer is ${one.await() + two.await()}")
    }
    println("Completed in $time ms")
}

fun calculateTimeTakenInAsynchronousLazyCalls() = runBlocking {
    val time = measureTimeMillis {
        val one = async(start = CoroutineStart.LAZY) { doSomethingUsefulOne() }
        val two = async(start = CoroutineStart.LAZY) { doSomethingUsefulTwo() }
        one.start()
        two.start()
        println("Final answer is ${one.await() + two.await()}")
    }
    println("Completed in $time ms")
}

Do you recall the era when we relied on AsyncTasks in Android? Those functions were callable from any part of the code. However, a significant issue arose with them: if the function or component that initiated the AsyncTask terminated due to an error, the AsyncTask continued to run in the background. This often led to memory leaks, necessitating explicit handling of such scenarios to prevent issues.

Coroutines address this problem by implementing structured concurrency. While they provide a means to opt out of structured concurrency by creating functions in an Async-style manner, it’s strongly advised against relying on this approach.

But still for our knowledge let’s understand how we can do so.

We can define async style functions that call our suspend functions asynchronously using the async coroutine builder using GlobalScope reference to opt out of structured concurrency.

val one = GlobalScope.async { doSomethingUsefulOne() }

Note: When we use GlobalScope, studio will give us an error:

This is a delicate API and its use requires care. Make sure you fully read and understand documentation of the declaration that is marked as a delicate API.

To get rid of this error, we will have to explicitly opt-in to use this API by adding this annotation on your function: @OptIn(DelicateCoroutinesApi::class)

Let’s try to execute our two suspend functions using GlobalScope and see what happens.

@OptIn(DelicateCoroutinesApi::class)
fun calculateTimeTakenInAsyncCall() {
    val time = measureTimeMillis {
        val one = GlobalScope.async { doSomethingUsefulOne() }
        val two = GlobalScope.async { doSomethingUsefulTwo() }
        runBlocking {
            println("Final answer is ${one.await() + two.await()}")
        }
    }
    println("Completed in $time ms")
}

Note a few points here:

1. calculateTimeTakenInAsyncCall fun is neither suspend nor it is wrapped inside a runBlocking or a coroutineScope like our previous functions (calculateTimeTakenInAsynchronousLazyCalls)
2. GlobalScope can be used from anywhere and the code inside this scope will execute asynchronously with the invoking code.
3. Though we can initiate asynchronous actions outside of a coroutineScope using a GlobalScope but waiting for a result must involve blocking or suspending.

Run this code and you will see that there is not much difference in the output.

But then Why async style functions are not recommended?

To understand this, let’s deliberately introduce an error in our doSomethingUsefulTwo function and observe how our code behaves when we utilise GlobalScope by adding a few more print statements.

suspend fun doSomethingUsefulOne(): Int {
    delay(2400)
    println("Task one is getting executed")
    return 33
}

suspend fun doSomethingUsefulTwo(): Int {
    delay(1500)
    // this will cause an Arithmetic Exception as we are diving 5 by 0
    val suffix = Math.floorDiv(5, 0)
    println("Task two is getting executed")
    return 6 + suffix
}

@OptIn(DelicateCoroutinesApi::class)
fun calculateTimeTakenInAsyncCallError() {
    try {
        val time = measureTimeMillis {
            val one = GlobalScope.async<Int> {
                try {
                    doSomethingUsefulOne()
                } catch (e: CancellationException) {
                    println("Task one is cancelled")
                    0
                } finally {
                    println("Task one finally block executed ")
                }
            }
            val two = GlobalScope.async<Int> {
                try {
                    doSomethingUsefulTwo()
                } catch (e: CancellationException) {
                    println("Task two is cancelled")
                    0
                } finally {
                    println("Task two finally block executed")
                }
            }
            runBlocking {
                delay(500)
                println("Final answer is ${one.await() + two.await()}")
            }
        }
        println("Completed in $time ms")
    } catch (e: Exception) {
        println(e)
    }
}

When we run this code, we will see that even if an error occurred before the await functions could get called, the doSomethingUsefulOne suspend functions completes it’s execution in the background as it was running independently and didn’t consider the scope lifecycle.

But in real word applications, this can back-fire in non-trivial ways. That is why, it is recommended to invoke long running operations in a coroutine scope.

Let’s see our output if we run the same code in the above example but using a coroutineScope or runBlocking instead of a GlobalScope

fun calculateTimeTakenInScopedCallWithError() = try {
    runBlocking {
        val time = measureTimeMillis {
            val one = async<Int> {
                try {
                    doSomethingUsefulOne()
                } catch (e: CancellationException) {
                    println("Task one is cancelled")
                    0
                } finally {
                    println("Task one finally block executed")
                }
            }
            val two = async<Int> {
                try {
                    doSomethingUsefulTwo()
                } catch (e: CancellationException) {
                    println("Task two is cancelled")
                    0
                } finally {
                    println("Task two finally block executed")
                }
            }
            delay(500)
            println("Final answer is ${one.await() + two.await()}")
        }
        println("Completed in $time ms")
    }
} catch (e: Exception) {
    println(e)
}

This time our task one got cancelled before completing because coroutineScope follows structured concurrency. When a coroutine inside a scope throws an exception, it is being transferred

When can we use use global scope