Rust Atomics and Locks: Low-Level Concurrency in Practice
- Length: 150 pages
- Edition: 1
- Language: English
- Publisher: O'Reilly Media
- Publication Date: 2023-01-31
- ISBN-10: 1098119444
- ISBN-13: 9781098119447
- Sales Rank: #100627 (See Top 100 Books)
The Rust programming language is extremely well-suited for concurrency, and its ecosystem has many libraries that include lots of concurrent data structures, locks, and more. But implementing those structures correctly can be very difficult. Even in the most well-used libraries, memory ordering bugs are not uncommon.
In this practical book, Mara Bos, leader of the Rust library team, helps Rust programmers of all levels gain a clear understanding of low-level concurrency. You’ll learn everything about atomics and memory ordering and how they’re combined with basic operating system APIs to build common primitives like mutexes and condition variables. Once you’re done, you’ll have a firm grasp of how Rust’s memory model, the processor, and the roles of the operating system all fit together.
With this guide, you’ll learn:
- How Rust’s type system works exceptionally well for programming concurrency correctly
- All about mutexes, condition variables, atomics, and memory ordering
- What happens in practice with atomic operations on Intel and ARM processors
- How locks are implemented with support from the operating system
- How to write correct code that includes concurrency, atomics, and locks
- How to build your own locking and synchronization primitives correctly
Foreword Preface Who This Book is For Overview of the Chapters Conventions Used in This Book Using Code Examples O’Reilly Online Learning How to Contact Us Acknowledgments 1. Basics of Rust Concurrency Threads in Rust Scoped Threads Shared Ownership and Reference Counting Statics Leaking Reference Counting Borrowing and Data Races Interior Mutability Cell RefCell Mutex and RwLock Atomics UnsafeCell Thread Safety: Send and Sync Locking: Mutexes and RwLocks Rust’s Mutex Lock Poisoning Reader-Writer Lock Waiting: Parking and Condition Variables Thread parking Condition Variables Summary 2. Atomics Atomic Loads and Stores Example: Stop Flag Example: Progress Reporting Synchronization Example: Lazy Initialization Fetch-and-Modify Operations Example: Progress Reporting from Multiple Threads Example: Statistics Example: ID Allocation Compare-and-Exchange Operations Example: ID Allocation Without Overflow Example: Racy Lazy Initialization Summary 3. Memory Ordering Reordering and Optimizations The Memory Model Happens-Before Relationship Spawning and Joining Relaxed Ordering Release and Acquire Ordering Example: Locking Example: Racy Lazy Initialization with Indirection Consume Ordering Sequentially Consistent Ordering Fences Common Misconceptions Summary 4. Building Our Own Spin Lock A Minimal Implementation An Unsafe Spin Lock A Safe Interface Using a Lock Guard Summary 5. Building Our Own Channels A Simple Mutex Based Channel An Unsafe One-Shot Channel Safety Through Runtime Checks Safety Through Types Borrowing to Avoid Allocation Blocking Summary 6. Building Our Own “Arc” Basic Reference Counting Testing It Mutation Weak Pointers Testing It Optimizing Summary 7. Understanding the Processor Processor Instructions Load and Store Read-Modify-Write Operations x86 Lock Prefix x86 Compare-and-Exchange Instruction Load-Linked and Store-Conditional Instructions ARM Load-Exclusive and Store-Exclusive Compare-and-Exchange on ARM Caching Cache Coherence The Write-Through Protocol The MESI Protocol Impact on Performance Reordering Memory Ordering x86-64: Strongly Ordered ARM64: Weakly Ordered An Experiment Memory Fences Summary 8. Operating System Primitives Interfacing with the Kernel Posix Wrapping in Rust Linux Futex Futex Operations Priority Inheritance Futex Operations macOS os_unfair_lock Windows Heavy-Weight Kernel Objects Lighter-Weight Objects Slim Reader-Writer Locks Address Based Waiting Summary 9. Building Our Own Locks Mutex Avoiding Syscalls Optimizing Further Benchmarking Condition Variable Avoiding Syscalls Avoiding Spurious Wake-ups Reader-Writer Lock Avoiding Busy-Looping Writers Avoiding Writer Starvation Summary 10. Ideas and Inspiration Semaphore RCU Lock-Free Linked List Queue Based Locks Parking Lot Based Locks Sequence Lock Teaching Materials
Donate to keep this site alive
How to download source code?
1. Go to: https://www.oreilly.com/
2. Search the book title: Rust Atomics and Locks: Low-Level Concurrency in Practice
, sometime you may not get the results, please search the main title
3. Click the book title in the search results
3. Publisher resources
section, click Download Example Code
.
1. Disable the AdBlock plugin. Otherwise, you may not get any links.
2. Solve the CAPTCHA.
3. Click download link.
4. Lead to download server to download.