
Rust Atomics and Locks
Description
Alles über E-Books | Antworten auf Fragen rund um E-Books, Kopierschutz und Dateiformate finden Sie in unserem Info- & Hilfebereich.
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 role 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
More details
Other editions
Additional editions

Content
- Cover
- Copyright
- Table of Contents
- Foreword
- Preface
- Who This Book Is For
- Overview of the Chapters
- Code Examples
- Conventions Used in This Book
- Contact Information
- Acknowledgments
- Chapter 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
- Chapter 2. Atomics
- Atomic Load and Store Operations
- Example: Stop Flag
- Example: Progress Reporting
- 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: Lazy One-Time Initialization
- Summary
- Chapter 3. Memory Ordering
- Reordering and Optimizations
- The Memory Model
- Happens-Before Relationship
- Spawning and Joining
- Relaxed Ordering
- Release and Acquire Ordering
- Example: Locking
- Example: Lazy Initialization with Indirection
- Consume Ordering
- Sequentially Consistent Ordering
- Fences
- Common Misconceptions
- Summary
- Chapter 4. Building Our Own Spin Lock
- A Minimal Implementation
- An Unsafe Spin Lock
- A Safe Interface Using a Lock Guard
- Summary
- Chapter 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
- Chapter 6. Building Our Own "Arc"
- Basic Reference Counting
- Testing It
- Mutation
- Weak Pointers
- Testing It
- Optimizing
- Summary
- Chapter 7. Understanding the Processor
- Processor Instructions
- Load and Store
- Read-Modify-Write Operations
- Load-Linked and Store-Conditional Instructions
- Caching
- Cache Coherence
- Impact on Performance
- Reordering
- Memory Ordering
- x86-64: Strongly Ordered
- ARM64: Weakly Ordered
- An Experiment
- Memory Fences
- Summary
- Chapter 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
- Heavyweight Kernel Objects
- Lighter-Weight Objects
- Address-Based Waiting
- Summary
- Chapter 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
- Chapter 10. Ideas and Inspiration
- Semaphore
- RCU
- Lock-Free Linked List
- Queue-Based Locks
- Parking Lot-Based Locks
- Sequence Lock
- Teaching Materials
- Index
- About the Author
- Colophon
System requirements
File format: PDF
Copy-Protection: Adobe-DRM (Digital Rights Management)
System requirements:
- Computer (Windows; MacOS X; Linux): Install the free reader Adobe Digital Editions prior to download (see eBook Help).
- Tablet/smartphone (Android; iOS): Install the free app Adobe Digital Editions or the app PocketBook before downloading (see eBook Help).
- E-reader: Bookeen, Kobo, Pocketbook, Sony, Tolino and many more (only limited: Kindle).
The file format PDF always displays a book page identically on any hardware. This makes PDF suitable for complex layouts such as those used in textbooks and reference books (images, tables, columns, footnotes). Unfortunately, on the small screens of e-readers or smartphones, PDFs are rather annoying, requiring too much scrolling.
This eBook uses Adobe-DRM, a „hard” copy protection. If the necessary requirements are not met, unfortunately you will not be able to open the eBook. You will therefore need to prepare your reading hardware before downloading.
Please note: We strongly recommend that you authorise using your personal Adobe ID after installation of any reading software.
For more information, see our eBook Help page.