Rust Atomics and Locks (Mara Bos)（Z-Library）

# Rust Atomics and Locks: Low-Level Concurrency in Practice ## 【One-Line Pitch】 A practical, deep-dive guide for Rust programmers who want to master low-level concurrency—atomics, memory ordering, and building synchronization primitives from scratch—written by the leader of the Rust library team. If you've ever wondered how mutexes actually work under the hood or why memory ordering bugs sneak into even well-tested code, this book is for you. ## 【Book Arc】 - **Opening (~0%–6%)**: Sets the stage for why low-level concurrency is hard, introduces the book's scope (atomics, memory ordering, OS APIs, building primitives), and outlines the journey from Rust's type system to practical lock implementation. - **Early (~6%–25%)**: Covers Rust concurrency fundamentals—thread spawning, scoped threads, the "Leakpocalypse" history lesson, shared ownership via statics and Arc, interior mutability (Cell, RefCell), and the basics of Mutex and RwLock. - **Early (~25%–34%)**: Explores practical synchronization patterns with Mutex, Condvar, and thread parking—including a producer-consumer queue example—and introduces the concept of memory ordering as a prerequisite for atomics. - **Middle (~38%–47%)**: Dives into atomic operations: load/store, fetch-and-modify operations (fetch_add, fetch_or, etc.), ID allocation examples with overflow handling, and compare-and-exchange loops for correct concurrent updates. - **Middle (~47%–53%)**: Continues with advanced atomic patterns including lazy one-time initialization, and transitions toward memory ordering details (Release/Acquire, Consume, Sequentially Consistent) and fences. - **Late (~53%–end)**: Moves into building real synchronization primitives—a spin lock from scratch (minimal, unsafe, then safe with a lock guard) and channels (mutex-based, unsafe one-shot, safety through runtime checks and types). ## 【Key Takeaways】 - **Rust's type system is the first line of defense for concurrency** (Early): The borrow checker prevents data races at compile time, and types like MutexGuard encode locking guarantees—unlocking happens automatically on drop, making it impossible to forget. - **The "Leakpocalypse" shaped modern Rust concurrency** (Early): Safe interfaces cannot rely on Drop being called; this historical lesson explains why std::thread::scoped was removed and later redesigned, and why std::mem::forget is safe. - **Atomics are the concurrent version of Cell** (Early): They copy values in and out as a whole without borrowing, but are limited to specific types (AtomicU32, AtomicPtr, etc.) depending on processor support—they're tools to enable sharing bigger data structures. - **Relaxed ordering guarantees consistency per-variable only** (Middle): It doesn't promise anything about relative ordering between different variables—two threads may observe operations on different variables in different orders. - **Compare-and-exchange loops are the key to correct concurrent updates** (Middle): The naive fetch_add approach for ID allocation can overflow and wrap; the correct pattern checks the condition before modifying, using compare_exchange_weak in a loop. - **Mutexes and Condvars solve different problems** (Early): Mutex provides exclusive access to data; Condvar handles notification when conditions change (like queue non-empty), with time-limited variants (park_timeout, wait_timeout) for robustness. - **Building primitives from scratch teaches deep understanding** (Late): The book walks through implementing a spin lock (minimal → unsafe → safe with guard) and channels (mutex-based → unsafe one-shot → type-safe), showing how safety can be enforced through runtime checks or the type system. ## 【Reading Tips】 - **Skim Chapter 1 if you're comfortable with Rust basics**—threads, scoped threads, and Mutex usage are foundational but familiar territory; focus on the "Leakpocalypse" section for historical context that explains current API design. - **Deep-read the atomics chapters (2–3)**: These are the heart of the book. Pay special attention to the ID allocation examples—they show subtle overflow bugs and how compare_exchange_weak solves them correctly. - **Work through the spin lock and channel implementations in later chapters**: These are the payoff—they synthesize everything from earlier chapters into real, working primitives. Don't just read; try implementing them yourself first. - **Watch for the memory ordering discussion**: The distinction between Relaxed, Release/Acquire, Consume, and Sequentially Consistent is subtle. The book's examples (stop flag, locking, lazy initialization) make these concrete—use them as mental models. - **The excerpts don't cover the full memory ordering chapter or fences in depth**—if those are your primary interest, you'll need the complete book for the full treatment. ## 【Coverage Limits】 This guide covers the book's opening through roughly the middle of the atomics chapters (up to ~53%), including fundamentals, basic synchronization, and atomic operations. The later chapters on memory ordering details, fences, and full primitive implementations are only partially represented in the source material. ##