Asynchronous Programming and Kotlin Coroutines in Android

Asynchronous programming is very important and it’s now a common part of modern application. It increases the amount of work that an app can execute by allowing tasks to execute in parallel. This makes sure that heavy tasks run in the background, keeping the UI thread responsive and improving the overall user experience.

Kotlin Coroutines

The Kotlin team defines coroutines as “lightweight threads”. They are sort of tasks that the actual threads can execute. Coroutines were added to Kotlin in version 1.3 and are based on established concepts from other languages. Kotlin coroutines introduce a new style of concurrency that can be used on Android to simplify async code.

The official documentation says that coroutines are lightweight threads. By lightweight, it means that creating coroutines doesn’t allocate new threads. Instead, they use predefined thread pools and smart scheduling for the purpose of which task to execute next and which tasks later.

Types of Coroutines

There are two types of Coroutines:

• Stackless Coroutines – These do no maintain their own stack and do not map directly to native threads.
• Stackful Coroutines – These maintain their own threads. (not used in Kotlin)

Kotlin implements stackless coroutines, meaning they operate without their own stack and are not directly tied to native threads.

Why Do We Need Coroutines?

As we know android developers today have many async tools in hand. These include RxJava, AsyncTasks, Jobs, Threads. But, these methods come with several challenges which includes:

• RxJava – Safe Usage is complex and has a steep learning curve.
• AsyncTasks & Threads – These can easily introduce leaks and memory overhead.
• Callbacks – Complex, unreadable and excessive code.

Android is a single thread platform, By default, everything runs on the main thread. In Android, almost every application needs to perform some non UI operations like (Network call, I/O operations), so when coroutines concept is not introduced, what is done is that programmer dedicate this task to different threads, each thread executes the task given to it, when the task is completed, they return the result to UI thread to update the changes required. Though In android there is a detailed procedure given, about how to perform this task in an effective way using best practices using threads, this procedure includes lots of callbacks for passing the result among threads, which ultimately introduce tons of code in our application and the waiting time to get the result back to increases.

On Android, Every app has a main thread (which handles all the UI operations like drawing views and other user interactions. If there is too much work happening on this main thread, like network calls (eg fetching a web page), the apps will appear to hang or slow down leading to poor user experience.

Kotlin Coroutines Features

Coroutines is the recommended solution for asynchronous programming on Android. Some highlighted features of coroutines are given below.

• Lightweight: One can run many coroutines on a single thread due to support for suspension, which doesn’t block the thread where the coroutine is running. Suspending frees memory over blocking while supporting multiple concurrent operations.
• Built-in cancellation support: Cancellation is generated automatically through the running coroutine hierarchy.
• Fewer memory leaks: It uses structured concurrency to run operations within a scope.
• Jetpack integration: Many Jetpack libraries include extensions that provide full coroutines support. Some libraries also provide their own coroutine scope that one can use for structured concurrency.

Kotlin Coroutines vs Threads

Kotlin Coroutines Dependencies

Add these dependencies in build.gradle.kts Module-level file.

dependencies {
  implementation ("org.jetbrains.kotlinx:kotlinx-coroutines-core:x.x.x")
  implementation ("org.jetbrains.kotlinx:kotlinx-coroutines-android:x.x.x")
}

Note: Replace x.x.x with the latest coroutine version. As of Feb 2025, the latest and stable version of Kotlin Coroutines is 1.10.1

Kotlin Coroutines Example

Let’s say we want to fetch some users from the database and show it on the screen. For fetching the data from the database we have to perform the network call, fetch the user from the database, and show it on the screen. Fetching the user can be done by using either by using callbacks or coroutines.

Using Callbacks:

Less readable code

fun fetchAndShowUser() {
  fetchUser   {
    user -> showUser(user)
  }
}

Using Coroutines:

This has a more cleaner code

suspend fun fetchAndShowUser() {
  val user = fetchUser() 
  showUser(user)
}

As discussed above using callbacks will decrease the code readability, so using coroutines is much better to use in terms of readability and performance as well. As discussed above Coroutines has many advantages apart from not having callbacks, like they are nonblocking, easy, and nonexpensive to create.       

L

lavishgarg26

Follow

Improve

Article Tags :

• Android
• Kotlin Android