Kotlin coroutines anatomy (TBD)



How thread work under the hood

  • Share memory
  • Thread vs ThreadLocal
  • Thread memory footprint

    Thread communication

Pros & Cons

  • Mutex (atomic)
  • Asynchronous
  • Race condition
  • Dead lock
  • Visibility & mutual object


Process communication


  • Concept exist since 1950 (1960?)
  • Also available in other language likes Go, Perl and Python

Coroutines element

  • Suspendable function
  • Coroutine builder: function that create coroutine and return Job
  • Coroutine scope: include coroutine context: control how coroutine setup, cancel coroutine and choose which thread to run coroutine
  • Coroutine context: rules for exceute coroutine
  • Job & CoroutineDispatcher make up a coroutine context
  • Job: track coroutine state, allow coroutines to be track and manually cancel early
  • CoroutineDispatcher: dispatch coroutine to desire thread, build-in dispatchers:
    • Dispatchers.Default: for general work, thread pool size = number of CPU core
    • Dispatchers.IO: for IO work, thread pool size with high number of thread
    • Dispatchers.Main: UI/main thread
    • Dispatchers.Unconfined
  • async/await
  • Deferred
  • Continuation

Coroutines builder

  • launch
  • async

    How coroutines work

Coroutines under the hood

Structured concurrency

Coroutines communication

Coroutines evolution

  • Sequential programming
  • Callback hell Off-load work with worker thread and callback
  • Rx
  • Promise, Future, Deffer, Completable

    Coroutines vs Thread


What is the pattern of Couroutines lib

  • Thread low-level API vs Coroutines is high-level API under the hood it used thread pool
  • Each thread cost around ~2M memory footprint
  • Threads share memory in process


  • Off-load work to worker thread

Pros vs Cons

  • Standalone lib


  1. https://speakerdeck.com/elizarov
  2. https://dzone.com/articles/how-much-memory-does-a-java-thread-take