Practical Swift Concurrency Make the most out of Concurrency in Swift 5.7 and beyond (Donny Wals)（Z-Library）

【One-Line Pitch】 A hands-on guide to Swift Concurrency for iOS developers who want to move past Grand Central Dispatch and write async/await code that is correct, testable, and fast. Best for working Swift developers with some GCD background who want practical patterns rather than language-theory depth. 【Book Arc】 - **Opening (~0%–9%)**: Frames the book's purpose and gives a chapter-by-chapter roadmap, from concurrency fundamentals through async/await, tasks, testing, and Instruments profiling. - **Early (~9%–27%)**: Establishes the conceptual baseline — concurrency vs. parallelism, threads vs. cores, and why a single-threaded program blocks while waiting on input. - **Early (~27%–39%)**: Explains how the CPU interleaves work, why atomic operations freeze apps, and how multi-core parallelism plus a separate main thread keeps UI responsive during network calls. - **Middle (~39%–52%)**: Shows the risks of multi-threading (data races on shared arrays) and reviews pre-Concurrency Swift: GCD queues, serial vs. parallel execution, and the thread-explosion problem Swift Concurrency aims to fix. - **Late (~52%–75%)**: Moves into Swift Concurrency proper — async/await syntax, async contexts, writing your own async functions, and tasks as the new unit of concurrency (no thread talk, no thread explosion). - **Ending (~75%–100%)**: Covers migrating existing code, async sequences and the async algorithms package vs. Combine, parallel work with `async let` and task groups, testing async code with XCTest, and debugging/profiling with Instruments. 【Key Takeaways】 - **Concurrency is not parallelism** (Early): Concurrency means the CPU interleaves multiple tasks over time; parallelism means two or more threads run simultaneously on separate cores. This distinction underpins every later chapter. - **The main thread must stay free** (Early): UI rendering and user interaction live on the main thread, so slow work like network calls belongs elsewhere — the book uses a button-tap network fetch to show why. - **Data races are the hidden cost of multi-threading** (Middle): When parallel threads write to shared memory like a matches array, readers can see inconsistent state and memory can corrupt; synchronization is mandatory. - **GCD's thread explosion is a design flaw, not a bug you can fix** (Middle): Dispatch queues can spawn more threads than CPU cores, forcing expensive context switching — a problem Swift Concurrency eliminates by design. - **Tasks are the foundation of Swift Concurrency** (Late): The book stresses that we no longer talk about threads; tasks are the new thread, and thread count is capped at CPU cores. - **Async/await is introduced gradually** (Late): You learn async and throwing-async syntax, async vs. sync contexts, and how to write your own async functions — including ones that never suspend. - **Parallelism scales through structured tools** (Ending): `async let` and task groups let you spawn child tasks that run in parallel, enabling a data fetcher that makes hundreds of network calls at once. - **Testing and profiling are first-class concerns** (Ending): XCTest support for async code, when to fall back to older testing methods, and using Instruments to inspect task states, actor scheduling, and fix real performance issues. 【Reading Tips】 - **Skim Chapter 1 if you already know concurrency vs. parallelism**, but read the data-race section carefully — it sets up the actors chapter later. - **Use Chapter 2 as a GCD refresher, not a deep dive**: the author explicitly says he won't cover all GCD details, only the problems Swift Concurrency solves. - **Deep-read the tasks chapter (Ch. 4)**: it is the conceptual hinge of the book — if you understand tasks, the rest of the concurrency model falls into place. - **Treat the async sequences/Combine chapter as optional** unless you are migrating from Combine or need the async algorithms package. - **Do the Instruments chapter with a real project open**: the sample app with deliberate performance issues is where the debugging lessons stick. 【Coverage Limits】 The excerpts cover the book's preface, chapter overview, and portions of Chapters 1–2 plus brief summaries of later chapters; detailed code examples, actor internals, and full chapter content are not included, so this guide reflects the book's structure and stated goals rather than every technical detail.