Understanding the Difference Between Executing Coroutine with and without Suspend IO Methods

Learn how Kotlin coroutines handle IO operations and the impact of `suspend` methods. This guide breaks down the concepts to help you avoid common pitfalls and exceptions in your code.
---

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: diff between executing coroutine with and without suspend-ed IO methods

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding the Difference Between Executing Coroutine with and without Suspend IO Methods

Kotlin coroutines have revolutionized asynchronous programming by allowing developers to write cleaner, non-blocking code. However, when dealing with IO operations using coroutines, it's vital to understand the differences in behavior between suspend and non-suspend functions.

Problem Overview

In the given code example, you have two methods to insert records into a database using Room, a persistence library for Android:

[[See Video to Reveal this Text or Code Snippet]]

The first method with the suspend keyword works seamlessly.

The second method without the suspend keyword throws an exception:

[[See Video to Reveal this Text or Code Snippet]]

What Happens Under the Hood?

Function Behavior:

The suspend function allows the coroutine to pause its execution and continue later. This means the database insertion will happen on a background thread to ensure that the UI thread remains responsive.

Conversely, the non-suspend function runs on whatever thread it is called from, which in this case is the main thread.

Thread Safety:

Google's design decisions prevent developers from performing intensive operations on the main thread, as it can lead to a janky user experience (laggy or unresponsive UI). Whenever a non-suspend function is executed on the main thread, Room checks the thread context and throws an exception to maintain UI responsiveness.

Thread Utilization:

For the suspend function (i.e., insert_SuspendFun), Room utilizes a thread pool to perform the IO operation, allowing the coroutine to yield control back to the main thread while waiting for the operation to complete.

Breaking it Down

How suspend Functions Work

A suspend function can pause the execution of the calling coroutine without blocking the thread.

These functions commonly call other suspend functions or use mechanisms like:

withContext: Switches the coroutine context, allowing the caller to do blocking work on specific threads (e.g., IO Dispatcher).

suspendCoroutine or suspendCancellableCoroutine: Provide advanced control of coroutine suspension and resumption.

Implementation Insights

While we can't see the exact generated code for the DAO, it's speculated that Room employs suspendCancellableCoroutine for insert_SuspendFun, letting the IO operation run in a separate background thread and resuming the coroutine without causing UI thread blocking.

Why Does it Run on the Main Thread?

Coroutine Scope: The viewModelScope used in the onButtonInsert function runs on the main thread because Android needs certain functions to execute there to interact with UI components.

You can override this behavior, for instance, using:

[[See Video to Reveal this Text or Code Snippet]]

This is, however, not the conventional approach unless necessary, as it can complicate the code and introduce confusion.

Conclusion

Understanding the implications of using suspend functions versus non-suspend functions in Kotlin coroutines is crucial for effective Android development. By using suspend functions for IO operations, you ensure that the main thread remains free to handle UI tasks, thus providing a smoother user experience.

Next time you find yourself working with Room and coroutines, remember the significance of the suspend keyword and how it influences threading in your application.