Coroutine Gotchas – Bridging the Hole between Coroutine and Non-Coroutine Worlds | Weblog | bol.com


Coroutines are an exquisite method of writing asynchronous, non-blocking code in Kotlin. Consider them as light-weight threads, as a result of that’s precisely what they’re. Light-weight threads intention to cut back context switching, a comparatively costly operation. Furthermore, you may simply droop and cancel them anytime. Sounds nice, proper?

After realizing all the advantages of coroutines, you determined to present it a attempt. You wrote your first coroutine and known as it from a non-suspendible, common perform… solely to search out out that your code doesn’t compile! You are actually looking for a technique to name your coroutine, however there aren’t any clear explanations about how to try this. It looks as if you aren’t alone on this quest: This developer received so annoyed that he’s given up on Kotlin altogether!

Does this sound acquainted to you? Or are you continue to in search of one of the best methods to hyperlink coroutines to your non-coroutine code? In that case, then this weblog put up is for you. On this article, we’ll share essentially the most elementary coroutine gotcha that each one of us stumbled upon throughout our coroutines journey: Tips on how to name coroutines from common, blocking code?

We’ll present three other ways of bridging the hole between the coroutine and non-coroutine world:

  • GlobalScope (higher not)
  • runBlocking (watch out)
  • Droop all the best way (go forward)

Earlier than we dive into these strategies, we’ll introduce you to some ideas that may enable you to perceive the other ways.

Suspending, blocking and non-blocking

Coroutines run on threads and threads run on a CPU . To raised perceive our examples, it is useful to visualise which coroutine runs on which thread and which CPU that thread runs on. So, we’ll share our psychological image with you within the hopes that it’ll additionally enable you to perceive the examples higher.

As we talked about earlier than, a thread runs on a CPU. Let’s begin by visualizing that relationship. Within the following image, we are able to see that thread 2 runs on CPU 2, whereas thread 1 is idle (and so is the primary CPU):

Latest articles

Related articles

Leave a reply

Please enter your comment!
Please enter your name here