Hands-On Concurrency with Rust Confidently build memory-safe, parallel, and efficient software in Rust (Brian L. Troutwine)（Z-Library）

【One-Line Pitch】 A hands-on guide to writing memory-safe concurrent and parallel Rust, moving from machine architecture and ownership through locks, atomics, and high-level parallelism to FFI and embedding. Best for Rust programmers who already write sequential code and want to reason rigorously about threads, synchronization, and performance. 【Book Arc】 - **Opening (~0%–10%)**: Sets up the premise that parallel programming is hard but tractable, and frames the book as a "book of beginnings" rather than a complete reference. Introduces the toolchain and the idea of mechanical sympathy with modern hardware. - **Early (~10%–35%)**: Builds foundations: machine architecture (CPU, caches, memory model), sequential Rust performance and testing (QuickCheck, AFL, Criterion, Valgrind, perf), the Rust memory model (ownership, references, Box, Rc, Cell/RefCell, custom allocators), and the Sync/Send traits as the basis of concurrency. - **Middle (~35%–60%)**: Moves into synchronization: coarse-grained locks (Mutex, Condvar, Barrier, RwLock) illustrated through the hopper MPSC project, then fine-grained atomics and lock-free data structures, followed by the hard problem of safely reclaiming memory (reference counting, hazard pointers, epoch-based reclamation, Crossbeam). - **Late (~60%–80%)**: Covers high-level parallelism via thread pools, parallel iterators, and the Rayon project, applied to a data-parallel project. Also extends into FFI and embedding: combining Rust with C, Lua (rlua), Python, and Erlang/Elixir. - **Ending (~80%–100%)**: Looks ahead at near-term Rust developments—SIMD, hex encoding, futures and async/await, specialization—plus interesting projects like fuzzing and Seer, and closes with a discussion of when to use unsafe and the role of community. 【Key Takeaways】 - **Parallel programming is a learnable skill, not a black art** (Opening): the book's core premise is that concurrency can be done well when you pay attention to the computing environment and validate your programs carefully. - **Mechanical sympathy matters** (Early): understanding CPU caches, memory hierarchies, and bus behavior is treated as prerequisite knowledge for writing fast concurrent code, not an optional detour. - **Sequential performance comes first** (Early): an entire chapter is devoted to profiling and testing single-threaded Rust before introducing concurrency, using tools like Criterion, Valgrind, perf, QuickCheck, and AFL. - **Rust's memory model is C++-inspired but adds reference consumption** (Middle): atomic orderings follow LLVM/C++11, so C++ literature transfers, but Rust's ownership rules (a value used zero or one times) change how you reason about shared state. - **Sync and Send are the foundation of Rust concurrency** (Early/Middle): safety by exclusion—using the type system to prevent data races—is presented as the conceptual bedrock before any synchronization primitive is introduced. - **Coarse synchronization is taught through real projects** (Middle): Mutex, Condvar, Barrier, and RwLock are demonstrated via the hopper MPSC specialization and smaller data-structure exercises rather than toy snippets. - **Atomics are genuinely difficult and deserve deep treatment** (Middle): lock-free data structures and atomic primitives are covered at length, with the caveat that this is "an exceedingly difficult topic." - **Memory reclamation is the central challenge of lock-free code** (Late): reference counting, hazard pointers, and epoch-based reclamation are each examined in detail, with Crossbeam discussed extensively as a production-grade reference. 【Reading Tips】 - Deep-read the early chapters on machine architecture and the memory model even if you think you know them—later atomic and lock-free material depends on this foundation. - Treat the hopper, Rayon, and FFI projects as the practical spine: download the source, run it, and probe it with your own tools rather than reading passively. - Skim the tooling walkthroughs (GDB/lldb, Valgrind, perf) on a first pass, then return when you actually need to profile or debug a concurrent program. - Expect the atomics and memory-reclamation chapters to be slow going; the author explicitly says learning should proceed at its own pace and that not every chapter will click immediately. - Use the "Further reading" sections as a launchpad—the book positions itself as an entry point into the existing literature, not a final word. 【Coverage Limits】 The excerpts cover the book's structure, preface, and several chapter openings, but do not include the full body of code examples or the detailed content of later chapters. Specific implementation details, figures, and complete chapter titles beyond those mentioned may not be fully represented here.