Hands-On Concurrency with Rust: Confidently build memory-safe, parallel, and efficient software in Rust

Book Synopsis: Effectively meet modern software demands by using Rust's safe and powerful memory model

Key Features

• Learn and improve the sequential performance characteristics of your software
• Understand the use of operating system processes in a high-scale concurrent system
• Explore the different coordination methods available in the standard library

Book Description
Most programming languages can be challenging to work with, especially with regard to unsafe memory access. Moreover, the burden on you as a programmer involves two aspects: understanding the modern machine and your language's pain points. To help you tackle this, Hands-On Concurrency with Rust will guide you on how to manage program performance on modern machines and build fast, memory-safe, and concurrent software in Rust.
The book starts with the fundamentals of Rust and focuses on machine architecture concepts. You will then explore ways to measure and improve the performance of Rust code systematically and how to confidently write collections. As you progress, you will learn about the Sync and Send traits applied to threads, and coordinate thread execution with locks, atomic primitives, data-parallelism, and more. The book will also assist you in efficiently embedding Rust in C++ code, before helping you discover the functionalities of different crates for multithreaded applications. In later chapters, you'll go on to understand the implementations of lock-free and wait-free structures. You will also get up to speed with how a mutex works, along with learning to build them yourself. Finally, you'll master radically different approaches that exist in the ecosystem for structuring and managing high-scale systems.
By the end of this book, you will have gained the expertise you need to design safe, consistent, parallel, and high-performance applications in Rust.

What you will learn

• Examine your programs for performance and accuracy issues
• Create your own threading and multi-processing environment in Rust
• Use coarse locks from Rust's standard library
• Solve common synchronization problems or avoid synchronization using atomic programming
• Build lock-free and wait-free structures in Rust and understand their implementations in the crates ecosystem
• Leverage Rust's memory model and type system to integrate safety properties into your parallel programs
• Understand the new features of the Rust programming language to ease the process of writing parallel programs

Who This Book Is For
This book is for software engineers with a basic understanding of Rust, who want to safely use the parallel and concurrent nature of modern computing environments.

Table of Contents

1. Preliminaries: Machine Architecture and Getting Started with Rust
2. Sequential Rust Performance and Testing
3. The Rust Memory Model: Ownership, References and Manipulation
4. Sync and Send: the Foundation of Rust Concurrency
5. Locks: Mutex, Condvar, Barriers and RWLock
6. Atomics: The Primitives of Synchronization
7. Atomics: Safely Reclaiming Memory
8. High-Level Parallelism: Threadpools
9. FFI and Embedding: Combining Rust and Other Languages
10. Futurism: Near-Term Rust