You're reading for free via Android Dev Nexus' Friend Link. Become a member to access the best of Medium.
Member-only story
Common Coroutine Interview Questions 📝

🌟Members can scroll down to enjoy! Non-members, click here for the full access to our blog.🌟
Hello you genius devs! 👩🏻💻
Welcome to yet another exciting blog of our ongoing Android Interview Prep series! 🚀 Our goal is to boost your confidence and arm you with the important questions to help you ace your Android interviews. Today, let’s dive into common coroutine-related interview questions.
1. What are Coroutines and Why Use Them?

This is a foundational question. You can answer it like this:
“Coroutines are lightweight threads used for asynchronous programming in Kotlin. They are used to write non-blocking code, which improves performance and responsiveness, especially in Android apps. Coroutines help eliminate callback hell and make code easier to read and maintain.”
💡 Pro tip: Mention that coroutines are a key feature in Android development, making network requests and database operations smooth.
2. Explain launch
vs async
in Kotlin Coroutines.
Both launch
and async
are used to start coroutines, but they differ in how they return results.
launch
: Returns aJob
and is used when you don’t need to return a result.
launch { performTask() }
async
: Returns aDeferred
and is used when you want to return a result. You can await the result withawait()
.
val result = async { fetchData() }.await(
💡 Pro tip: In interviews, explain when you’d use each. Use launch
for fire-and-forget operations and async
when you need a result.
3. What is suspend
and how does it work?
This is one of the core concepts in coroutines.
“suspend
is a keyword used to mark a function as suspendable, meaning it can be paused and resumed later. These functions run within coroutines and allow the thread to perform other tasks while waiting for a result, without blocking the thread."
💡 Pro tip: Be ready to show an example of a suspend
function and explain how it's non-blocking.
4. What is runBlocking
, and when should you use it?
runBlocking
is a coroutine builder that bridges regular blocking code and suspending functions. It blocks the current thread until its code block completes. Here's a good way to explain it:
“runBlocking
is primarily used in testing or in main functions for quick examples. In production code, it should be avoided in favor of non-blocking coroutine builders likelaunch
andasync
."
💡 Pro tip: Emphasize that runBlocking
should not be used in Android's main thread, as it blocks the UI.
5. What are Coroutine Scopes and how do you use them?
Understanding coroutine scopes is essential, especially in Android.
“A Coroutine Scope manages the lifecycle of coroutines. It defines when a coroutine starts and when it should be canceled. For example, in Android, you might use
viewModelScope
to ensure coroutines are tied to the lifecycle of aViewModel
, orlifecycleScope
for activities and fragments."
💡 Pro tip: Bring up Android-specific coroutine scopes like viewModelScope
or lifecycleScope
to show practical knowledge.
6. What are withContext
and Dispatchers
, and why are they important?
This question delves into the importance of switching between threads.
“withContext
is used to switch the context (thread) in which a coroutine runs. You can use it to offload work from the main thread to a background thread withDispatchers.IO
, or switch back to the main thread withDispatchers.Main
."
withContext(Dispatchers.IO) {
// Perform background task
}
💡 Pro tip: Show your knowledge of different dispatchers — Dispatchers.Main
, Dispatchers.IO
, and Dispatchers.Default
—and explain when to use them.

7. What are Structured Concurrency
and Coroutine Scope Builders
?
Structured concurrency ensures that coroutines are launched in a controlled hierarchy, so you don’t end up with untracked, leaking coroutines.
“Structured concurrency ensures that when a coroutine scope finishes, all coroutines within that scope are also completed. Builders like
launch
andasync
ensure that coroutines have clear lifecycles and are properly canceled if needed."
8. How do you handle exceptions in coroutines?
You can catch exceptions in coroutines just like in regular code, but Kotlin also provides coroutine-specific mechanisms like CoroutineExceptionHandler
.
val handler = CoroutineExceptionHandler { _, exception ->
println("Caught $exception")
}
GlobalScope.launch(handler) {
throw RuntimeException("Test exception")
}
💡 Pro tip: Mention that try-catch
can handle exceptions in suspending functions, but CoroutineExceptionHandler
is often used to handle uncaught exceptions in launch
.
In your next Kotlin interview, now you are ready to:
- Explain the fundamentals of coroutines and suspending functions.
- Compare
launch
andasync
, and when to use them. - Discuss scopes, exception handling, and structured concurrency.

What’s Next?
Want to dive deeper into Coroutines? 🌊
You’re in luck! Check out our Coroutines Cheat Sheet: A 2-Part Blog series that’ll uncover all the essentials to master Kotlin Coroutines in no time.
Give it a read and level up your Coroutine game! 😎
Good luck with your Kotlin interview, and may your coroutines always run smoothly! ✨
If you found this helpful, don’t forget to clap for the blog! Follow for more such posts.
Until then, happy coding!