C++并发编程实战(中文版) (Anthony Williams) (Z-Library)

【One-Line Pitch】 A deep, practical guide to writing correct and efficient concurrent C++ using the C++11 standard library—covering everything from `std::thread` and mutexes to lock-free data structures and the memory model. Best for developers who already know C++ and now need to reason rigorously about threads, shared data, and performance. 【Book Arc】 - **Opening (~0%–10%)**: Defines concurrency and multithreading, explains why (and when not) to use them, traces C++'s concurrency history, and walks through a first `std::thread` program. - **Early (~10%–20%)**: Thread management and synchronization primitives—launching/joining threads, passing arguments, `std::mutex`, `std::lock`, deadlock avoidance, condition variables, and `std::future`/`std::async`. - **Early–Middle (~20%–40%)**: The C++ memory model and atomics—`std::atomic`, compare-exchange, happens-before and synchronizes-with, then designing lock-based concurrent data structures (thread-safe stack, queue, lookup table). - **Middle (~40%–55%)**: Lock-free concurrent data structures—reference counting, hazard pointers, and the performance realities of atomic operations and false sharing. - **Late (~55%–80%)**: Designing concurrent code—thread pools, parallel algorithms (`parallel_for_each`, `parallel_accumulate`), and data layout for cache efficiency. - **Ending (~80%–100%)**: Testing and debugging multithreaded code, plus appendices on C++11 concurrency-related language features and a full thread-library reference. 【Key Takeaways】 - **Concurrency is about structure, not just speed** (Opening): The book frames concurrency as independent activities that may run simultaneously, and stresses deciding *whether* concurrency helps before reaching for threads. - **Thread lifetime must be managed explicitly** (Early): `std::thread` requires joining or detaching; passing arguments, handling move-only types, and identifying threads are recurring practical concerns. - **Protecting data is subtler than locking a mutex** (Early): Even a mutex-protected interface like a stack can harbor race conditions; you must protect whole operations, not just individual pointers, and avoid passing protected data outside the lock. - **Deadlock is avoidable with discipline** (Early): Key rules include avoiding nested locks, not calling user code while holding a lock, and acquiring multiple locks in a fixed order or via `std::lock`. - **Futures and async decouple task submission from result retrieval** (Early): `std::future`, `std::shared_future`, `std::async`, and packaged tasks let you express dependencies (e.g., spreadsheet-style computation) without manual thread plumbing. - **The memory model is the foundation of correctness** (Early–Middle): Happens-before, synchronizes-with, and memory ordering (`acquire`/`release`/`consume`) determine what one thread can safely observe from another. - **Lock-free is not automatically faster** (Middle): Atomic operations act like locks at the hardware level; false sharing and cache-line ping-pong can make lock-free structures slower, so measure before committing. - **Parallel algorithms need careful adaptation** (Late): Parallelizing `accumulate` or `for_each` changes iterator requirements, result combination, and exception handling—futures help propagate exceptions back to the caller. 【Reading Tips】 - **Skim Chapter 1 if you already know threads**; the book itself says experienced multithreaded developers can skip the introductory sections. - **Deep-read the memory model and atomics chapters**—these are the hardest and most consequential parts; revisit them when debugging subtle races. - **Treat the lock-free chapters as advanced material**: read them after you are comfortable with lock-based designs, and don't assume lock-free is the goal. - **Use the appendices as a reference**, not a linear read—they summarize C++11 concurrency features and the thread library for lookup. - **Focus on the design guidance and rules** (deadlock avoidance, data layout, exception safety) rather than memorizing every code listing. 【Coverage Limits】 The excerpts cover the book's opening through roughly the middle, including thread management, synchronization, the memory model, and lock-based/lock-free data structures; the later chapters on concurrent code design, testing, and the appendices are only partially represented. Specific chapter titles and figures beyond those mentioned are not fully covered by the excerpts.