Async Rust Unleashing the Power of Fearless Concurrency (Maxwell Flitton, Caroline Morton)（Z-Library）

【One-Line Pitch】 A hands-on guide to asynchronous Rust that takes you from the fundamentals of futures and tasks all the way to building your own async runtime, queues, and a dependency-free TCP server. Best for Rust developers who already know the language and want to understand async deeply rather than just use it. 【Book Arc】 - **Opening (~0%–10%)**: Frames what async is and why it matters for I/O-bound work, contrasting blocking vs. asynchronous timelines and situating async within processes, threads, and the OS. - **Early (~10%–35%)**: Introduces the core machinery of async Rust — tasks, futures, async/await, polling, context, wakers, and pinning — culminating in a worked async audit-logger example. - **Middle (~35%–50%)**: Consolidates understanding by building custom async queues from scratch, including multiple queues, task routing, task stealing, join macros, and basic runtime configuration. - **Late (~50%–75%)**: Extends the runtime into networking (executors, connectors, mio, sockets), then explores coroutines and generators, and reactive programming with an event bus. - **Ending (~75%–100%)**: Moves into customizing Tokio (runtime building, local pools, graceful shutdowns), async design patterns, actors, pub/sub, and unit/end-to-end testing of async systems. 【Key Takeaways】 - **Async is about I/O, not raw speed** (Opening): The book positions async as a tool for multitasking around I/O waits, not a universal performance win — useful for choosing the right concurrency model. - **Futures require pinning, context, and wakers** (Early): Understanding why futures can't move in memory and how wakers notify executors is the conceptual core that unlocks everything else. - **Tasks are the unit of async work** (Early): The task-based asynchronous pattern lets you write sequential-looking code that the runtime schedules concurrently. - **Building your own runtime demystifies the black box** (Middle): Implementing queues, task stealing, and join macros reveals how futures actually flow through an executor, making high-level crates easier to reason about. - **Coroutines underpin async/await** (Late): The book draws explicit parallels between coroutines and async tasks, showing async functionality can exist without extra threads. - **Reactive patterns and actors structure complex systems** (Late): Event buses, pub/sub, and actor-based designs are presented as practical ways to organize async communication. - **Tokio is customizable, not monolithic** (Ending): Runtime building, local pools, and graceful shutdowns give fine-grained control over task processing. - **Async code must be tested** (Ending): Unit and end-to-end testing of async systems is treated as a first-class skill, not an afterthought. 【Reading Tips】 - Deep-read the futures/pinning/context material in the early chapters — it's the hardest conceptual hurdle and everything later depends on it. - The networking chapter is flagged by the authors as skippable on a first pass; return to it after the queue-building chapter clicks. - Treat the queue-building chapter as the pivot point: it converts abstract concepts into something you can inspect and modify. - Skim the process/thread comparison if you already know OS concurrency; focus on where async sits relative to it. - Keep the audit-logger and TCP-server examples as reference implementations to adapt for your own projects. 【Coverage Limits】 This guide is based on stratified excerpts covering the preface, table of contents, and early-to-middle chapters; later chapters on Tokio customization, actors, and testing are summarized from the book's stated scope rather than detailed excerpt content.