Elements of Kotlin Coroutines Version 0.2 (Mark L. Murphy)（Z-Library）

【One-Line Pitch】 A practical, example-driven guide to Kotlin coroutines that takes you from "what is a coroutine?" to confidently structuring concurrent work with builders, jobs, flows, and channels. Best for Kotlin developers (especially Android) who want to write correct asynchronous code without callback hell. 【Book Arc】 - **Opening (~0%–10%)**: Frames the problem — asynchronous work and "callback hell" — and introduces coroutines as the solution, including the basic vocabulary of scope, builder, dispatcher, and suspend function. - **Early (~10%–32%)**: Covers the core building blocks: coroutine builders (`launch()`, `async()`), dispatchers and their defaults, `CoroutineScope` (including why `GlobalScope` is a code smell), and the fundamentals of `Job` management. - **Middle (~32%–55%)**: Deepens job control — lazy start, job states, cancellation (including cooperative cancellation, `cancelAndJoin()`, `NonCancellable`, and yielding), plus deferring results with `Deferred`. - **Late (~55%–80%)**: Moves into data streams: `Flow` (creation, consumption, dispatchers, operators, exceptions, `retry()`/`retryWhen()`), channels (send/receive, capacity, broadcasting), and `StateFlow`. - **Ending (~80%–100%)**: Bridges coroutines to existing callback-based APIs and shows how to create custom scopes, tying the pieces together for real-world integration. 【Key Takeaways】 - **Coroutines solve callback hell by letting you write sequential-looking async code** (Opening): suspend functions pause without blocking threads, so the same code reads top-to-bottom while running concurrently. - **Builders define intent: `launch()` for fire-and-forget, `async()` for results** (Early): `launch()` returns a `Job` for management; `async()` returns a `Deferred` whose `await()` yields the value. - **Dispatchers decide where code runs, and defaults are not always obvious** (Early): `Dispatchers.Default` is the usual default, but scopes like Android's `viewModelScope` use `Dispatchers.Main` — declaring your dispatcher explicitly is safest and most self-documenting. - **`GlobalScope` is a code smell in production** (Early): it lives for the whole process and is easy to misuse; prefer a focused `CoroutineScope` tied to a component's lifecycle. - **Cancellation is cooperative, not automatic** (Middle): a canceled job only stops when code checks in (e.g., `delay()`, `yield()`, or `withContext`); blocking loops like a busy-wait ignore cancellation entirely. - **`NonCancellable` lets cleanup finish after cancellation** (Middle): wrapping a `finally` block in `withContext(NonCancellable)` ensures essential cleanup runs even when the job is canceled. - **Flows are cold streams; channels are hot** (Late): `Flow` emits on collection and supports operators like `retry()`/`retryWhen()` for transient failures; channels support send/receive with capacity planning and broadcasting. - **`StateFlow` is the modern state-holder** (Late): it replaces `ConflatedBroadcastChannel` and compares favorably to `LiveData`, though it has its own limitations worth understanding. 【Reading Tips】 - **Deep-read the builders, jobs, and cancellation chapters** (Early–Middle): these are the foundation; skimming them will make later flow/channel material harder to follow. - **Skim the introductory callback-hell framing** (Opening) if you already know why async is hard — get to the coroutine mechanics quickly. - **Run the Klassbook samples as you go**: the book leans on executable snippets, and seeing output (especially for concurrency ordering) cements the mental model. - **Pay special attention to cancellation and dispatcher sections**: these are the most common sources of production bugs and the hardest spots to get right. - **Treat flows, channels, and `StateFlow` as a toolkit to compare**, not memorize — note when each is appropriate rather than learning every operator. 【Coverage Limits】 This guide is based on stratified excerpts covering the table of contents, preface, and selected chapters; some chapters (e.g., deferring results, structuring concurrency, custom scopes) are only partially represented, so specific details there may be understated.