Modern C Concurrency and Parallel Programming - new edition

About this book

**Modern C++ Concurrency and Parallel Programming** is an advanced practical guide to designing concurrent software that is not only fast, but also correct, maintainable, portable, and architecturally sound.

Concurrency books often fall into one of two extremes. Some remain at the level of API recipes—creating threads, locking mutexes, or signaling condition variables—without explaining the deeper correctness guarantees behind them. Others focus heavily on formal memory models and weak-memory theory but provide little guidance on how those concepts should influence the design of real software systems.

This book deliberately connects both worlds.

Professional C++ concurrency requires understanding **ownership, lifetime, synchronization, communication, cancellation, memory ordering, architecture, and performance as parts of the same problem**. A theoretically correct atomic ordering is useless if the referenced object is destroyed too early. A clean architecture remains unsafe if it contains a data race. And an impressive benchmark can be meaningless if it measures allocator contention, scheduling noise, or synchronization overhead rather than the algorithm being evaluated.

The book therefore adopts a repeatable engineering method for reasoning about concurrent systems:

**state the invariant → assign ownership → choose the communication model → establish ordering → define stopping behavior → measure performance**

The first step is always correctness. Readers are encouraged to identify the invariants that must remain true regardless of scheduling, processor behavior, or timing. From there, ownership and lifetime are made explicit: which component creates an object, which threads or tasks may access it, who may mutate it, and when it can safely be destroyed.

The book then compares the principal communication models used in modern concurrent C++ applications, including **shared mutable state, message passing, task-based execution, producer-consumer pipelines, channels, asynchronous operations, and dependency graphs**. Each model is examined in terms of synchronization requirements, scalability, failure behavior, and maintainability.

A substantial part of the material is dedicated to the C++ memory model. Readers learn how **atomics, synchronization operations, happens-before relationships, acquire/release ordering, sequential consistency, fences, and data-race rules** establish the guarantees on which concurrent algorithms depend. The emphasis is not merely on memorizing memory-order names, but on being able to explain precisely which operation synchronizes with another and why a program is correct.

Stopping and cancellation are treated as fundamental architectural concerns rather than afterthoughts. The book examines structured approaches using **`std::jthread`, `std::stop_token`, cooperative cancellation, failure propagation, shutdown coordination, and resource-safe termination**, helping developers answer what should happen when a user cancels an operation, a dependency fails, or the application begins shutting down.

The material distinguishes three practical maturity levels.

**Portable standard practice** covers concurrency facilities broadly available in C++20 and C++23 implementations.

**C++26 working-draft practice** examines the direction of the upcoming standard while clearly acknowledging that compiler and library availability, wording, and implementation completeness may still vary.

**Boost production practice** covers mature facilities that extend beyond today's standard library, especially in areas such as **networking, asynchronous event processing, completion tokens, channels, fibers, executors, and interprocess coordination**.

C++26 material is based on the **working draft generated July 26, 2026**, together with relevant WG21 proposals incorporated into that draft. Because the final published standard may still receive editorial adjustments, defect resolutions, or ballot-related changes, draft-specific material is identified accordingly.

Performance engineering is addressed only after correctness has been established. The book discusses realistic benchmarking, contention analysis, cache behavior, false sharing, synchronization costs, workload decomposition, allocator effects, scalability, and the difference between theoretical parallelism and measurable application performance.

The intended audience includes **intermediate and advanced C++ developers, systems programmers, library authors, performance engineers, infrastructure developers, and architects building multithreaded or asynchronous software**.

Ultimately, this book presents concurrency not as a collection of isolated APIs, but as a disciplined engineering process in which **correctness, ownership, synchronization, cancellation, architecture, and performance must be designed together**.