C++ includes built-in support for threads, atomic operations, mutual exclusion, condition variables, and futures.
Each instantiation and full specialization of the std::atomic template defines an atomic type. If one thread writes to an atomic object while another thread reads from it, the behavior is well-defined (see memory model for details on data races). In addition, accesses to atomic objects may establish inter-thread synchronization and order non-atomic memory accesses as specified by std::memory ...
Each atomic object has its own associated modification order, which is a total order of modifications made to that object. If, from some thread's point of view, modification A of some atomic M happens-before modification B of the same atomic M, then in the modification order of M, A occurs before B.
Atomically replaces the current value with desired. Memory is affected according to the value of order.
On success, the operation is an atomic read-modify-write operation on *this and expected is not accessed after the atomic update. On failure, the operation is an atomic load operation on *this and expected is updated with the existing value read from the atomic object.
atomic_compare_exchange_weak_explicit may fail spuriously. If expected is a null pointer, or failure is std::memory_order_release or std::memory_order_acq_rel, the behavior is undefined. If p is a null pointer, the behaviors of these functions are all undefined.
Atomically loads and returns the current value of the atomic variable. Memory is affected according to the value of order.
atomic_fetch_add, atomic_fetch_add_explicit ... Atomically replaces the value pointed by obj with the result of addition of arg to the old value of obj, and returns the value obj held previously. The operation is read-modify-write operation.