Hi, I am Amit Shekhar, Co-Founder @ Outcome School • IIT 2010-14 • I have taught and mentored many developers, and their efforts landed them high-paying tech jobs, helped many tech companies in solving their unique problems, and created many open-source libraries being used by top companies. I am passionate about sharing knowledge through open-source, blogs, and videos.

In this blog, we will learn about the coroutineScope vs supervisorScope of Kotlin Coroutines.

There is a major difference between the coroutineScope and the supervisorScope, and we must understand that difference otherwise we will make mistakes without knowing what is happening with the Kotlin Coroutines code.

This article was originally published at Outcome School.

As always, I am taking a real example use-case to understand this major difference between the coroutineScope and the supervisorScope.

Example use case:

Suppose, we have two network calls as follows:

• getUsers()
• getMoreUsers()

We want to make these two network calls in parallel to get the data from the server.

You can find the complete source code of this example here.

In Kotlin Coroutines, for doing tasks in parallel.

launch {
    try {
        coroutineScope {
            val usersDeferred = async {  getUsers() }
            val moreUsersDeferred = async { getMoreUsers() }
            val users = usersDeferred.await()
            val moreUsers = moreUsersDeferred.await()
        }
    } catch (exception: Exception) {
        // handle exception
    }
}

Now, if any network error comes, it will go to the catch block. We have used the coroutineScope.

But suppose again, we want to return an empty list for the network call which has failed and continue with the response from the other network call. We will have to use the supervisorScope and add the try-catch block to the individual network call as below:

launch {
    try {
        supervisorScope {
            val usersDeferred = async { getUsers() }
            val moreUsersDeferred = async { getMoreUsers() }
            val users = try {
                usersDeferred.await()
            } catch (e: Exception) {
                emptyList<User>()
            }
            val moreUsers = try {
                moreUsersDeferred.await()
            } catch (e: Exception) {
                emptyList<User>()
            }
        }
    } catch (exception: Exception) {
        // handle exception
    }
}

So now, if any error comes, it will continue with the empty list. This is how supervisorScope helps.

The major difference:

• A coroutineScope will cancel whenever any of its children fail.
• A supervisorScope won't cancel other children when one of them fails.

Note:

• Use coroutineScope with the top-level try-catch, when you do NOT want to continue with other tasks if any of them have failed.
• If we want to continue with the other tasks even when one fails, we go with the supervisorScope.
• Use supervisorScope with the individual try-catch for each task in addition to the top-level try-catch, when you want to continue with other tasks if one or some of them have failed.

This was all about the coroutineScope and the supervisorScope that are present in the Kotlin Coroutines.

That's it for now.

Thanks

Amit Shekhar

Co-Founder @ Outcome School

You can connect with me on:

• Twitter
• YouTube
• LinkedIn
• GitHub

Read all of our blogs here.