Swift 异步与并发编程 (王 巍)（Z-Library）

【One-Line Pitch】 A practical, code-first guide to Swift's modern concurrency model—async/await, structured concurrency, actors, and async sequences—for iOS/macOS developers who already know Swift and want to migrate callback-based code to a safer, more readable style. 【Book Arc】 - **Opening (~0%–10%)**: Defines core vocabulary—synchronous vs. asynchronous, serial execution, and why callback nesting ("callback hell") breaks error handling and code structure—then introduces async/await as the fix. - **Early (~10%–33%)**: Shows how to convert synchronous and callback-based functions into async functions, including continuations, async getters/setters, and the AsyncSequence/AsyncStream protocols for representing streams of future values. - **Middle (~33%–57%)**: Moves into structured concurrency—task groups, `async let`, task hierarchies, priorities, and cooperative cancellation—framing it as the concurrency analogue of structured programming versus `goto`. - **Late (~57%–80%)**: Covers task cancellation in depth (checking `isCancelled`, `checkCancellation`, cancellation handlers, resource cleanup with `defer`) and the actor model for data isolation and safety. - **Ending (~80%–100%)**: Touches on task-local values, task tracing, and a summary/outlook, including how Swift's executor model may evolve. (Excerpts do not cover the final chapters in detail.) 【Key Takeaways】 - **Async/await replaces callback nesting with linear, readable code** (Opening): it restores `try/throw` error handling and single-entry/single-exit flow that completion handlers destroy. - **Migration is a core skill** (Early): the general recipe is to drop the completion closure, add `async`, and turn `Error?` callbacks into `throws`; continuations bridge legacy delegate/callback APIs. - **AsyncSequence represents a series of future values** (Early): `AsyncStream` bridges synchronous producers (like `Timer`) into async iteration, but its default `.unbounded` buffering can overflow memory when producers outpace consumers. - **Don't share an async sequence across tasks** (Early): iterating the same sequence from multiple tasks causes a runtime crash—single-direction iteration is a design principle. - **Structured concurrency enforces single entry and exit** (Middle): `withTaskGroup` and `async let` create child tasks that must all finish (or cancel) before the parent completes, echoing the case against `goto`. - **Cancellation is cooperative, not automatic** (Middle/Late): you must check `Task.isCancelled` or call `checkCancellation`; ignoring it wastes resources and violates structured-concurrency expectations. - **Actors provide automatic data isolation** (Opening/Middle): converting a queue-protected class to an `actor` simplifies thread safety, with the compiler forcing `await` at isolation boundaries. - **Async sequences and Combine serve different goals** (Early): Combine excels at reactive event transformation; async sequences serve task/actor concurrency—the author advises against treating them as interchangeable. 【Reading Tips】 - Deep-read the early chapters on async function conversion and continuations—these are the migration skills you'll use daily. - Skim the conceptual history of structured programming vs. `goto` if you already grasp the idea; focus instead on the task-group and cancellation code. - Treat the cancellation chapter as essential: the `defer`/cancellation-handler pitfalls are easy to get wrong and hard to debug. - Keep the AsyncStream buffering discussion bookmarked—the producer/consumer speed mismatch is a real production risk. - If you use Combine, read the comparison section carefully to decide which tool fits each problem. 【Coverage Limits】 This guide is synthesized from stratified excerpts covering roughly the first half to two-thirds of the book; later chapters on task-local values, task tracing, and the final outlook are only lightly represented, so specifics there are not covered.