Kotlin Coroutines Deep Dive (Marcin Moskała)（Z-Library）

【One-Line Pitch】 A practical, example-driven guide to Kotlin coroutines that explains how suspension actually works under the hood and then shows how to apply scopes, dispatchers, cancellation, and flows in real Android and backend code. Best for Kotlin developers who already write coroutines and want to stop guessing about the runtime. 【Book Arc】 - **Opening (~0%–10%)**: Frames the problem coroutines solve — callback hell, blocked threads, and hard-to-cancel async code — then introduces suspension and resumption through the "save point" analogy and the `Continuation` object. - **Early (~10%–25%)**: Peels back the compiler transformation: how suspending functions become state machines with labels and captured locals, and how `suspendCoroutine`/`suspendCancellableCoroutine` bridge callback APIs. - **Early (~19%–32%)**: Moves into the `kotlinx.coroutines` library — `launch`, `async`/`Deferred`, `runBlocking`, `coroutineScope`, context inheritance, `Job` states, and the basics of cancellation. - **Middle (~32%–48%)**: Deepens structured concurrency: exception propagation, `supervisorScope` versus `coroutineScope`, dispatchers and `limitedParallelism`, `Dispatchers.Main.immediate`, continuation interception, and Android scope patterns (`ViewModel`, `SupervisorJob`). - **Middle (~48%–55%)**: Covers shared mutable state and synchronization primitives such as `Mutex` and `withLock`, plus testing suspending logic with `runBlocking` and fakes. - **Late/Ending (beyond ~55%)**: The excerpts do not cover the later chapters in detail; based on the book's structure, expect Flow, channels, and advanced production patterns, but this guide cannot summarize them. 【Key Takeaways】 - **Suspension is a save point, not a blocked thread** (Opening): A suspended coroutine returns a `Continuation` and consumes no thread; it can resume later, possibly on another thread. This is the conceptual key to everything else. - **The compiler turns `suspend` functions into state machines** (Early): Labels track the resume point, and locals become fields on a continuation object. Understanding this demystifies "magic" suspension and explains why suspending functions can only be called from coroutines. - **Bridge callback APIs with `suspendCancellableCoroutine`** (Early): Wrapping a callback (e.g., Retrofit) into a suspending function is a core skill; prefer the cancellable variant so cleanup hooks run on cancellation. - **Structured concurrency is the default, and that is the point** (Early–Middle): Builders inherit parent context and propagate failure upward. `coroutineScope` throws catchable exceptions, while `supervisorScope` isolates sibling failures — choose deliberately. - **`supervisorScope` is not interchangeable with `withContext(SupervisorJob())`** (Middle): The book flags this as a common trap; use the scope function when you want independent child tasks. - **Dispatchers are a resource decision** (Middle): `Dispatchers.IO` is a limited view of a shared pool; `limitedParallelism` creates independent limits, and blocking-heavy classes should own their dispatcher. Use `Main.immediate` to avoid redundant re-dispatch. - **Cancellation is cooperative and must be designed in** (Early–Middle): `finally` blocks still run, `invokeOnCancellation` handles cleanup, and `cancelAndJoin` waits for completion. Callback-based code is hard to cancel — another reason to adopt coroutines. - **Shared state needs explicit protection** (Middle): `Mutex.withLock` avoids the deadlock risk of manual `lock`/`unlock`; the excerpts introduce the problem but do not exhaustively cover all primitives. - **Testing suspending code is mostly ordinary testing** (Middle): `runBlocking` plus standard assertions and fakes covers many cases; the author notes his testing style is one preference among many. 【Reading Tips】 - **Deep-read Part 1 (the continuation/state-machine chapters)** even if you only skim later parts — it is the book's differentiator and makes debugging far easier. - **Skim the builder and dispatcher chapters if you already ship coroutine code**, but slow down on `coroutineScope` vs. `supervisorScope` and `SupervisorJob` — these are where production bugs hide. - **Run the snippets**: the book publishes executable sources and uses `println` output with timing annotations, so typing them out pays off. - **Treat the Android `ViewModel` scope patterns as templates**, then adapt the cancellation strategy (`cancelChildren` vs. `cancel`) to your lifecycle. - **Note the book's convention distinction** between `Flow` (type/concept) and a flow (instance); it keeps terminology precise as you move into the Flow chapters. 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book (fundamentals through testing); the later Flow, channel, and advanced-practice chapters are not represented here, so treat the Late/Ending arc as indicative only.