Concurrency with Modern C++

Concurrency in C++ is not just a matter of starting more threads. The harder questions concern shared state, memory ordering, synchronization, and the subtle ways a program can go wrong. Rainer Grimm’s Concurrency with Modern C++ works through those questions, connecting the language’s underlying rules with practical code and case studies.

Build a clear picture of the C++ memory model

The book starts with the foundations of concurrency in C++11 and C++14, including memory locations, atomics, and the ordering constraints that govern communication between threads. This grounding helps make later topics—such as acquire-release semantics, sequential consistency, and fences—easier to reason about.

From threads to parallel algorithms

Grimm examines thread management, mutexes and locks, condition variables, tasks, promises, and futures. The discussion then turns to parallel algorithms in the Standard Template Library, where execution policies and vectorized or parallel work raise their own questions about performance and correctness.

Learn through practical cases and patterns

Examples and case studies put concepts to work, including vector summation, thread-safe singleton initialization, and synchronization. Later chapters consider concurrent architecture, best practices, and the design of lock-based and lock-free data structures. The emphasis on pitfalls—including data races, deadlocks, and lifetime issues—keeps the focus on the careful reasoning reliable concurrent code demands.

Modern C++ features in context

The contents reach into C++20 and C++23 topics, including jthreads, cooperative interruption, atomic smart pointers, coroutines, semaphores, latches, barriers, and generator functions. Readers also encounter parallel programming patterns and the C++ time library.

For C++ programmers ready to go deeper

This book is aimed at developers who already work with C++ and want to understand concurrency beyond the surface-level mechanics. It offers a substantial route through the language’s concurrency tools, their underlying rules, and the design choices that help avoid common mistakes.