Kotlin Coroutines Cheat Sheet

kevinschildhorn profile image Kevin Schildhorn Updated on ・3 min read

Recently I was refreshing myself on kotlin coroutines, as I had worked with them before but never fulled grasped all the ins and outs of coroutines, and I decided to make some notes while I was reading through the docs (https://kotlinlang.org/docs/reference/coroutines/coroutines-guide.html).
I figured they would be helpful to other kotlin developers. Note that these are quick notes I jotted down and isn't a fully grammatical tutorial-esque article.


Coroutines are light-weight threads

CoroutineScope - Used to build coroutines, contains CoroutineContext
Scope Types:

  • GlobalScope - Lifetime of the new coroutine is limited only by the lifetime of the whole application
  • CoroutineScope - Is destroyed after all launched children are completed
  • MainScope - Scope for UI applications and uses Dispatchers.Main

CoroutineContext - A collection of various elements. Contains Job and CoroutineDispatcher
CoroutineDispatcher - Determines the thread(s) to use
Dispatcher types:

  • Unconfined - I’m working in thread main (appropriate for coroutines which neither consume CPU time nor update any shared data (like UI) confined to a specific thread)
  • Default - I'm working in thread DefaultDispatcher-worker-1
  • newSingleThreadContext - I’m working in thread MyOwnThread
  • main runBlocking - I’m working in thread main
  • newSingleThreadContext() - Creates new thread, can be used to switch between using withContext


  • Launch is a coroutine builder that returns a Job
  • Launch inherits the context from the scope it’s launched from
  • Customizing Launch:
    • Can pass variables between threads using asContextElement
    • Can name Coroutines using CoroutineName


  • Async is like launch, but returns a Deferred (i.e. future)
  • Async CoroutineStart.LAZY only starts when await is called


  • Jobs can be cancelled or call join, which works like pthread_join
  • Coroutine cancellation is cooperative, meaning if the coroutine isn’t checking if it’s cancelled then it won’t be cancelled
  • SupervisorJob is a job where cancellation is only propagated downwards
  • withTimeout creates a timeout for the coroutines (throws TimeoutCancellationException)
  • When cancelled:
    • Job throws an exception which can be handled with finally or catch (CancellationException)
    • All child coroutines are cancelled as well


  • Suspend can be used inside coroutines, but can also use other suspending functions
  • If a coroutine builder is inside suspend function a CoroutineScope needs to be added as well


  • runBlocking runs a new coroutine and blocks the current thread, interruptible until it’s completion
  • Delay is non blocking


  • Flow is an asynchronous stream of values
. Uses Emit and Collect to send and collect data
  • Flow runs in the context that is provided the collector
  • The code inside a flow isn’t run until the flow is collected
  • Flows can be cancelled with withTimeoutOrNull
  • Useful functions:
    • transform - customize data, such as emitting a header first
    • take - only take a certain amount of the flow
    • flowOn - change the context of preceding code
    • zip - combine multiple flows
    • catch - catch any exceptions of preceding code
    • onCompletion - perform any final tasks after the flow is done


  • Similar to a blocking queue, a way to transfer values between coroutines
  • Uses send and receive for normal values, produce and consume for streams
  • Channels can be closed to indicate no more elements are coming


  • Actor is an entity that can receive a class of messages using sealed classes. Meaning a consumer that takes in sealed classes

Let me know if I got anything wrong, or if I missed anything. Hope this helps!

Posted on by:

kevinschildhorn profile

Kevin Schildhorn


I'm a mobile developer at Touchlab, working in native Android, iOS, and Kotlin Multiplatform.


We are the Kotlin Multiplatform experts. We partner with mobile engineering leaders to accelerate feature development, maximize efficiency, and future-proof teams.


markdown guide