![\"TimelineCpp20Concurrency\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/10\/TimelineCpp20Concurrency.png\")
<\/p>\nThis post concludes my overview of C++20. Today’s post is about the concurrency features in the next C++ standard.<\/p>\n
<\/p>\n
<\/p>\n
C++20 has various concurrency improvements.<\/p>\n
The class template std::atomic_ref<\/span> applies atomic operations to the referenced non-atomic object. Concurrent writing and reading of the referenced object is no data race. The lifetime of the referenced object must exceed the lifetime of the atomic_ref. Accessing a subobject of the referenced object with an atomic_ref<\/span> is not thread-safe.<\/p>\n Accordingly to std::atomic, std::atomic_ref<\/span> can be specialized and supports specializations for the built-in data types.<\/p>\n std::shared_ptr<\/span> is the only non-atomic data type on which you can apply atomic operations. First, let me write about the motivation for this exception. The C++ committee saw the necessity that instances of std::shared_ptr<\/span> should provide a minimum atomicity guarantee in multithreading programs. What is this minimal atomicity guarantee for std::shared_ptr<\/span>? The control block of the std::shared_ptr<\/span> is thread-safe. This means that the increase and decrease operations of the reference counter are atomic. You also have the guarantee that the resource is destroyed exactly once.<\/p>\n Boost describes the assertions that a std::shared_ptr provides.<\/p>\n With C++20 we get two new smart pointers: std::atomic<std::shared_ptr<T>><\/span> and std::atomic<std::weak_ptr<T>>.<\/span><\/p>\n<\/p>\n In addition to C++11, you can create atomics for integral types and floating points. This is quite convenient when you have a floating-point number concurrently incremented by various threads. With a floating-point atomic, you don’t need to protect the floating pointer number.<\/p>\n std::atomic_flag<\/span> is an atomic boolean. It has a clear and set state. For simplicity reasons, I call the clear state false<\/span> and the set state true<\/span>. Its clear<\/span> method enables you to set its value to false<\/span>. With the test_and_set<\/span> method, you can set the value to true<\/span> and return the previous value. There is no method to ask for the current value. This will change with C++20. With C++20, a std::atomic_flag<\/span> has a test<\/span> method.<\/p>\n Additionally, std::atomic_flag<\/span> can be used for thread synchronization via the methods notify_one, notify_all,<\/span> and wait<\/span>. Notifying and waiting is with C++20 available on all partial and full specialization of std::atomic<\/span> (bools, integrals, floats and pointers) and std::atomic_ref.<\/span><\/p>\n All three types are means to synchronize threads.<\/p>\n Semaphores are a synchronization mechanism that controls concurrent access to a shared resource. A counting semaphore, such as the one in C++20, is a special semaphore with a counter bigger than zero. The counter is initialized in the constructor. Acquiring the semaphore decreases the counter, and releasing the semaphore increases the counter. If a thread tries to acquire the semaphore when the counter is zero, the thread will block until another thread increments the counter by releasing the semaphore.<\/p>\n Latches and barriers are simple thread synchronization mechanisms that enable some threads to block until a counter becomes zero.<\/p>\n What are the differences between these two mechanisms to synchronize threads? You can use a std::latch<\/span> only once, but you can use a std::barrier<\/span> more than once. A std::latch <\/span>is useful for managing one task by multiple threads; a std::barrier<\/span> is useful for managing repeated tasks by multiple threads. Additionally, a std::barrier<\/span> can adjust the counter in each iteration.<\/p>\n\nstruct<\/span> Counters {\r\n int<\/span> a;\r\n int<\/span> b;\r\n};\r\n\r\nCounter counter;
\r\nstd::<\/span>atomic_ref<<\/span>Counters><\/span> cnt(counter);\r\n<\/pre>\n<\/div>\nstd::atomic<std::shared_ptr<T>><\/span> and std::atomic<std::weak_ptr<T>><\/span><\/h3>\n
\n
Floating Point Atomics<\/h3>\n
Waiting on Atomics<\/h3>\n
Semaphores, Latches, and Barriers<\/h3>\n
Semaphores<\/h4>\n
Latches and Barriers<\/h4>\n
![\"threadJoinable\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/10\/threadJoinable.png\")
<\/p>\n![\"jthreadJoinable\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/10\/jthreadJoinable.png\")
<\/p>\n