???

CP: Concurrency and parallelism

We often want our computers to do many tasks at the same time (or at least appear to do them at the same time). The reasons for doing so vary (e.g., waiting for many events using only a single processor, processing many data streams simultaneously, or utilizing many hardware facilities) and so do the basic facilities for expressing concurrency and parallelism. Here, we articulate principles and rules for using the ISO standard C++ facilities for expressing basic concurrency and parallelism.

Threads are the machine-level foundation for concurrent and parallel programming. Threads allow running multiple sections of a program independently, while sharing the same memory. Concurrent programming is tricky, because protecting shared data between threads is easier said than done. Making existing single-threaded code execute concurrently can be as trivial as adding std::async or std::thread strategically, or it can necessitate a full rewrite, depending on whether the original code was written in a thread-friendly way.

The concurrency/parallelism rules in this document are designed with three goals in mind:

environment

standard library

the performance gains needed

• To help in writing code that is amenable to being used in a threaded
• To show clean, safe ways to use the threading primitives offered by the
• To offer guidance on what to do when concurrency and parallelism aren't giving

It is also important to note that concurrency in C++ is an unfinished story. C++11 introduced many core concurrency primitives, C++14 and C++17 improved on them, and there is much interest in making the writing of concurrent programs in C++ even easier. We expect some of the library-related guidance here to change significantly over time.

This section needs a lot of work (obviously). Please note that we start with rules for relative non-experts. Real experts must wait a bit; contributions are welcome, but please think about the majority of programmers who are struggling to get their concurrent programs correct and performant.

Concurrency and parallelism rule summary:

• CP.1: Assume that your code will run as part of a multi-threaded program
• CP.2: Avoid data races
• CP.3: Minimize explicit sharing of writable data
• CP.4: Think in terms of tasks, rather than threads
• CP.8: Don't try to use volatile for synchronization
• CP.9: Whenever feasible use tools to validate your concurrent code

See also:

• CP.con: Concurrency
• CP.coro: Coroutines
• CP.par: Parallelism
• CP.mess: Message passing
• CP.vec: Vectorization
• CP.free: Lock-free programming
• CP.etc: Etc. concurrency rules