Android Interview Series 2024 — Part 5 (Kotlin Coroutines)

This is Part 5 of the android interview question series. This part will focus on Kotlin coroutines.

1. What are coroutines?

Coroutine stands for cooperating functions. They provide a more efficient and readable way to handle asynchronous tasks. It is similar to a thread, in that it takes a block of code to run that works concurrently with the rest of the code. However, a coroutine is not bound to any particular thread. It may suspend its execution in one thread and resume in another one. Coroutines were launched to Kotlin in version 1.3.

2. How do coroutines differ from traditional threading?

• Coroutines are lightweight — We can run many coroutines on a single thread due to its support for suspension. Here suspension means that you can execute some instructions, then stop the coroutine in between the execution and continue when you wish to. Suspending saves memory over blocking while supporting many concurrent operations.
• Coroutines have fewer memory leaks — coroutines follow the structured concurrency principle, which means that each coroutine should be launched inside a specific context with a determinate life-time. Structured concurrency is an approach where the lifetime of coroutines is tied to a specific scope, ensuring that all launched coroutines within that scope complete before the scope itself completes. This helps avoid coroutine leaks and simplifies resource management.
• On android, coroutines offer Main-safety — coroutines help to manage long-running tasks that might otherwise block the main thread and cause your app to become unresponsive. Main-safety allows you to ensure that any suspend function can be called from the main thread.
• Coroutines offer built-in cancellation support — one of the most important mechanisms of coroutines is cancellation because, on Android, nearly every coroutine is associated with some view, and if this view is destroyed, its coroutines are not needed, so they should be cancelled. This is a crucial capability that used to require a lot of effort from developers, but coroutines offer a simple and safe cancellation mechanism.
• Coroutines are cooperatively multitasked — this means that coroutines are concurrency primitives that cooperatively execute a set of instructions and that the operating system doesn’t control the scheduling of tasks or processes performed by coroutines. Instead, it relies on the program, and platform that runs them to do that. As such, coroutines can yield control back to the scheduler to allow other threads to run. Scheduler from OS is responsible to let these threads do their job and if need be can also pause them so that the same resources can be used by other threads.

3. What is structured concurrency?

Structured concurrency is a design principle where the lifetime of coroutines is tied to a specific scope, ensuring that all launched coroutines within that scope complete before the scope itself completes. It ties the lifecycle of coroutines to the scope they are launched in, ensuring they are properly cancelled when the scope is no longer active. Key concepts of structured concurrency include:

• Hierarchical Structure: Coroutines launched in a scope form a parent-child relationship, where the parent coroutine is responsible for managing the lifecycle of its children.
• Automatic Cancellation: With structured concurrency, if a coroutine within a scope fails, other coroutines in the same scope are canceled automatically, preventing incomplete or inconsistent tasks.
• Scope-Aware Exception Handling: Exceptions in child coroutines can be propagated to the parent, ensuring that the entire operation fails fast if any part of it fails.

4. What are suspend functions?

Suspending functions are those functions that can be paused and then continued later. While the suspend function is executing, the coroutine releases the thread on which it was running and allows other coroutines to access that thread (because coroutines are cooperative).

The syntax of the suspended function is the same as that of the normal function but with the addition of the suspend keyword. Suspend functions are only allowed to be called from a coroutine or another suspend function.

suspend fun fetchUserData(): User {
val response = apiService.getUser()  // Assume this is a suspending API call
return response
}

5. How would you define a coroutine scope?

• A coroutine scope defines the lifecycle/lifetime of a coroutine. It is responsible for controlling the lifecycle of a group of coroutines and their context.
• Each coroutine scope has a context that can include a dispatcher (like Dispatchers.IO for background work, Dispatchers.Main for UI updates, etc.) and other configuration settings. Coroutines launched within the scope inherit this context, making it easy to handle the specifics of threading or exception handling.
• Coroutine scopes help ensure that coroutines are canceled if they’re no longer needed. For instance, in an Android app, the lifecycle of a coroutine scope is often tied to a component like a ViewModel or Activity. When the component is destroyed, all coroutines within its scope are canceled to avoid memory leaks or unnecessary background work.
• By grouping related coroutines under a single scope, you can manage tasks as a group. For example, in an API call with several concurrent requests, you might want to cancel all requests if one fails. The coroutine scope helps to implement this pattern effectively.
• A coroutine scope allows you to catch exceptions across all coroutines within it, ensuring consistent error handling without needing to manage each coroutine separately.

6. What are the 3 primary coroutine scopes?

In Kotlin, there are three primary coroutine scopes commonly used, especially in Android development, to manage the lifecycle of coroutines:

• GlobalScope: is a predefined coroutine scope that lives for the duration of the application’s lifetime. Coroutines launched in GlobalScope are not tied to any specific lifecycle or component. Therefore, they are never canceled automatically and continue running as long as the app is alive. Since it lacks structured concurrency, it’s often discouraged for most use cases, as it can lead to memory leaks or wasted resources if not managed carefully.

GlobalScope.launch {
// Do some long-running work
}

• CoroutineScope: is a general-purpose coroutine scope that you can define with a specific lifecycle and context. It’s commonly used to create custom coroutine scopes, especially in classes that need to control coroutine lifecycles explicitly (e.g., repositories, service classes). With CoroutineScope, you can specify a Job or dispatcher, making it more flexible and adaptable.

class MyRepository {
private val scope = CoroutineScope(Job() + Dispatchers.IO)
fun fetchData() {
scope.launch {
// Coroutine runs on Dispatchers.IO
}
}
fun clear() {
scope.cancel() // Cancels all coroutines launched in this scope
}
}

viewModelScope, lifecycleScope: These scopes are specific to Android and simplify coroutine management by tying coroutine lifecycles to Android components. They automatically cancel coroutines based on the lifecycle of the component, reducing the need for explicit cleanup.

• viewModelScope: Tied to a ViewModel’s lifecycle, coroutines launched in this scope are canceled automatically when the ViewModel is cleared.
• lifecycleScope: Available for Activity or Fragment, it cancels coroutines when the component’s lifecycle reaches a specific state (e.g., onDestroy).

7. What are coroutine builders?

Coroutine builders are functions for initialising or creating new coroutines. They simplify the process of launching coroutines and help define the structure of concurrent tasks. Each builder serves a different purpose, depending on how you want the coroutine to behave.

8. What are the different coroutine builders?

• launch: is the most common coroutine builder, that launches a new coroutine concurrently, i.e., without blocking the current thread. It’s typically used for fire-and-forget tasks where you don’t need a return value. launch creates a Job that represents the coroutine and can be used to manage its lifecycle (e.g., cancel it). launch is used a lot on ViewModels to create a bridge from non-suspending code to suspending code.

launch {
delay(1000L)
println("Hello World!")    
}

• async: like the launch function, it is also used to launch a new coroutine; the only difference is that it returns a deferred instead of a Job. The deferred is a non-blocking future that promises to deliver the result later. The running coroutine is cancelled when the resulting deferred is cancelled. You can call await() on this Deferred to get the result once the coroutine completes. It’s commonly used for parallel execution of tasks when you need to retrieve and combine results.

val deferred1 = async { fetchDataFromNetwork() }
val deferred2 = async { fetchDataFromDatabase() }
// Wait for both results
val result = deferred1.await() + deferred2.await()

• runBlocking: runs a new coroutine and blocks the current thread until its completion. In other words, the thread that runs in it gets blocked for the given duration until all the code blocks inside the brackets of run-blocking complete their execution. It’s primarily used in unit tests or in main functions where you need to call suspending functions but don’t have a coroutine context. It should be used sparingly in Android development since it blocks the main thread, potentially causing UI freezes.

fun main() = runBlocking {
// Calls a suspending function and waits for it to complete
fetchData()
}

• withContext: It is a suspending function that is used to switch coroutine context within a coroutine. It suspends the current coroutine, switches to the specified context, and resumes execution in the new context. withContext is synchronous within a coroutine and returns the result directly, making it useful for switching between threads seamlessly within a coroutine. You’ll be using it most of the time to switch the dispatcher the coroutine will be executed on.

val result = withContext(Dispatchers.IO) {
fetchDataFromNetwork()
}
// Now you can use the result on the main thread
textView.text = result

9. What is the concept of CoroutineContext?

Coroutine Context is a set of elements that define the behaviour and characteristics of a coroutine. It includes things like dispatchers, jobs, exception handlers, and coroutine name. The context is used to determine how and where the coroutine will be executed.

10. How would you define Coroutine Dispatcher?

A Coroutine Dispatcher is responsible for determining the thread or threads on which the coroutine will be executed. It controls where the coroutine’s code executes. Kotlin provides several standard dispatchers:

• Dispatchers.Main: Runs the coroutine on the main (UI) thread, useful for updating UI elements.
• Dispatchers.IO: IO Dispatchers initiate the coroutine on the IO thread. This one is suitable for I/O operations that can block the execution thread, such as reading or writing files, making database queries, or making network requests.
• Dispatchers.Default: The default dispatcher is used when no other dispatcher is explicitly specified in the scope. It takes advantage of a pool of shared background threads. This is a good option for compute-intensive coroutines that need CPU resources.
• Dispatchers.Unconfined: Starts the coroutine in the current thread but does not confine it to any specific thread afterward. It is appropriate for coroutines that do not consume CPU or update shared data confined to a specific thread.

val job = Job()
val scope = CoroutineScope(job + Dispatchers.Main)
scope.launch {
// This coroutine will be tied to the 'job' lifecycle
}
// Cancel all coroutines in this scope by canceling the job
job.cancel()

scope.launch {
try {
delay(5000) // This coroutine will be canceled if scope.cancel() is called
} catch (e: CancellationException) {
println("Coroutine was canceled") // Optional: Perform cleanup or logging
} finally {
// Use finally to release resources or perform additional cleanup
println("Clean up resources")
}
}

val exceptionHandler = CoroutineExceptionHandler { _, exception ->
println("Caught exception: ${exception.message}")
}
scope.launch(exceptionHandler) {
val data = fetchDataFromNetwork() // Exception will be caught by exceptionHandler
}