C++ Concurrency in Action (second edition, published 2019 by Manning Publications) is the definitive reference and guide to writing multithreaded code with Standard C++. It is suitable for all levels of C++ programmers, including those who have never previously written any multithreaded code. This book will show you how to write robust multithreaded applications in C++ while avoiding common pitfalls.
It's not just the best current treatment of C++11's threading facilities ... it's likely to remain the best for some time to come.Scott Meyers
This book should be on every C++ programmer's desk. It's clear, concise, and valuable.Rob Green, Bowling Green State University
Systems with multiple processors or processors with multiple cores are the norm these days; even many phones have multicore processors. To take advantage of these processor cores you need to use concurrency, either in the form of multiple processes or multiple threads.
The C++17 standard provides extensive support for writing multithreaded code to take advantage of these multicore and multiprocessor systems. C++ Concurrency in Action explains how these facilities work, and how to use them to best effect.
This book provides a tutorial covering the use of the library facilities introduced in the last three
C++ standards. It covers everything from the basics such
an in-depth description of the new memory model and
std::atomic classes for low level
synchronization and the new C++17 parallel algorithms. In later chapters, the book then goes on to
cover the design of multithreaded code, including lock-free data structures and thread
pools. Finally, there is a chapter on testing and debugging multithreaded applications.
It doesn't stop there though: the appendices include a brief overview of the some of the C++ language features either used by the multithreading facilties, or commonly used in conjunction with them, such as variadic templates, lambda functions and rvalue references, as well as a 150 page reference covering every class and function in the C++ Standard Thread Library. The book also covers the additional facilities from the Concurrency TS that aren't yet part of the main C++ standard.
Additional material in the second edition
In addition to all the material from the first edition, the second edition (published in 2019) includes full coverage of the library changes from C++14 and C++17:
std::shared_timed_mutex. These provide for multiple-reader/single-writer mutex locks.
std::scoped_lockfrom C++17 for locking multiple mutexes together.
- Parallel overloads of many standard library algorithms
Plus, full coverage of the library extensions from the concurrency TS:
std::experimental::latchto allow waiting for a set number of events to occur
std::experimental::flex_barrierto synchronize groups of threads
std::experimental::atomic_shared_ptrto allow atomic accesses to a single
shared_ptrinstance from multiple threads, as a better alternative that the
- Extended futures that allow continuations, so additional functions can be scheduled for when a future is ready.
std::experimental::when_anyto allow waiting for either all of a set of futures to be ready, or the first of a set of futures to be ready.