# Concurrency support library (since C++11)

From cppreference.com
< cpp

C++ includes built-in support for threads, atomic operations, mutual exclusion, condition variables, and futures.

### Threads

Threads enable programs to execute across several processor cores.

Defined in header `<thread>`
thread (C++11) | manages a separate thread (class)
jthread (C++20) | std::thread with support for auto-joining and cancellation (class)
##### Functions managing the current thread
Defined in namespace `this_thread`
yield (C++11) | suggests that the implementation reschedule execution of threads (function)
get_id (C++11) | returns the thread id of the current thread (function)
sleep_for (C++11) | stops the execution of the current thread for a specified time duration (function)
sleep_until (C++11) | stops the execution of the current thread until a specified time point (function)

### Thread cancellation The `stop_XXX` types are designed to enable thread cancellation for `std::jthread`, although they can also be used independently of `std::jthread` - for example to interrupt `std::condition_variable_any` waiting functions, or for a custom thread management implementation. In fact they do not even need to be used to "stop" anything, but can instead be used for a thread-safe one-time function(s) invocation trigger, for example.
Defined in header `<stop_token>`
stop_token (C++20) | an interface for querying if a std::jthread cancellation request has been made (class)
stop_source (C++20) | class representing a request to stop one or more std::jthreads (class)
stop_callback (C++20) | an interface for registering callbacks on std::jthread cancellation (class template)
| (since C++20)

### Cache size access

Defined in header `<new>`
hardware_destructive_interference_size hardware_constructive_interference_size (C++17) | min offset to avoid false sharing max offset to promote true sharing (constant)

### Atomic operations

These components are provided for fine-grained atomic operations allowing for lockless concurrent programming. Each atomic operation is indivisible with regards to any other atomic operation that involves the same object. Atomic objects are free of data races.

Neither the `_Atomic` macro, nor any of the non-macro global namespace declarations are provided by any C++ standard library header other than `<stdatomic.h>`. | (since C++23)

Defined in header `<atomic>`
##### Atomic types
atomic (C++11) | atomic class template and specializations for bool, integral, and pointer types (class template)
atomic_ref (C++20) | provides atomic operations on non-atomic objects (class template)
##### Operations on atomic types
atomic_is_lock_free (C++11) | checks if the atomic type's operations are lock-free (function template)
atomic_store atomic_store_explicit (C++11)(C++11) | atomically replaces the value of the atomic object with a non-atomic argument (function template)
atomic_load atomic_load_explicit (C++11)(C++11) | atomically obtains the value stored in an atomic object (function template)
atomic_exchange atomic_exchange_explicit (C++11)(C++11) | atomically replaces the value of the atomic object with non-atomic argument and returns the old value of the atomic (function template)
atomic_compare_exchange_weak atomic_compare_exchange_weak_explicit atomic_compare_exchange_strong atomic_compare_exchange_strong_explicit (C++11)(C++11)(C++11)(C++11) | atomically compares the value of the atomic object with non-atomic argument and performs atomic exchange if equal or atomic load if not (function template)
atomic_fetch_add atomic_fetch_add_explicit (C++11)(C++11) | adds a non-atomic value to an atomic object and obtains the previous value of the atomic (function template)
atomic_fetch_sub atomic_fetch_sub_explicit (C++11)(C++11) | subtracts a non-atomic value from an atomic object and obtains the previous value of the atomic (function template)
atomic_fetch_and atomic_fetch_and_explicit (C++11)(C++11) | replaces the atomic object with the result of bitwise AND with a non-atomic argument and obtains the previous value of the atomic (function template)
atomic_fetch_or atomic_fetch_or_explicit (C++11)(C++11) | replaces the atomic object with the result of bitwise OR with a non-atomic argument and obtains the previous value of the atomic (function template)
atomic_fetch_xor atomic_fetch_xor_explicit (C++11)(C++11) | replaces the atomic object with the result of bitwise XOR with a non-atomic argument and obtains the previous value of the atomic (function template)
atomic_wait atomic_wait_explicit (C++20)(C++20) | blocks the thread until notified and the atomic value changes (function template)
atomic_notify_one (C++20) | notifies a thread blocked in atomic_wait (function template)
atomic_notify_all (C++20) | notifies all threads blocked in atomic_wait (function template)
##### Flag type and operations
atomic_flag (C++11) | the lock-free boolean atomic type (class)
atomic_flag_test_and_set atomic_flag_test_and_set_explicit (C++11)(C++11) | atomically sets the flag to true and returns its previous value (function)
atomic_flag_clear atomic_flag_clear_explicit (C++11)(C++11) | atomically sets the value of the flag to false (function)
atomic_flag_test atomic_flag_test_explicit (C++20)(C++20) | atomically returns the value of the flag (function)
atomic_flag_wait atomic_flag_wait_explicit (C++20)(C++20) | blocks the thread until notified and the flag changes (function)
atomic_flag_notify_one (C++20) | notifies a thread blocked in atomic_flag_wait (function)
atomic_flag_notify_all (C++20) | notifies all threads blocked in atomic_flag_wait (function)
##### Initialization
atomic_init (C++11)(deprecated in C++20) | non-atomic initialization of a default-constructed atomic object (function template)
ATOMIC_VAR_INIT (C++11)(deprecated in C++20) | constant initialization of an atomic variable of static storage duration (function macro)
ATOMIC_FLAG_INIT (C++11) | initializes an std::atomic_flag to false (macro constant)
##### Memory synchronization ordering
memory_order (C++11) | defines memory ordering constraints for the given atomic operation (enum)
kill_dependency (C++11) | removes the specified object from the std::memory_order_consume dependency tree (function template)
atomic_thread_fence (C++11) | generic memory order-dependent fence synchronization primitive (function)
atomic_signal_fence (C++11) | fence between a thread and a signal handler executed in the same thread (function)
Defined in header `<stdatomic.h>`
##### C compatibility macros
_Atomic (C++23) | compatibility macro such that _Atomic(T) is identical to std::atomic<T> (function macro)

### Mutual exclusion

Mutual exclusion algorithms prevent multiple threads from simultaneously accessing shared resources. This prevents data races and provides support for synchronization between threads.

Defined in header `<mutex>`
mutex (C++11) | provides basic mutual exclusion facility (class)
timed_mutex (C++11) | provides mutual exclusion facility which implements locking with a timeout (class)
recursive_mutex (C++11) | provides mutual exclusion facility which can be locked recursively by the same thread (class)
recursive_timed_mutex (C++11) | provides mutual exclusion facility which can be locked recursively by the same thread and implements locking with a timeout (class)
Defined in header `<shared_mutex>`
shared_mutex (C++17) | provides shared mutual exclusion facility (class)
shared_timed_mutex (C++14) | provides shared mutual exclusion facility and implements locking with a timeout (class)
##### Generic mutex management
Defined in header `<mutex>`
lock_guard (C++11) | implements a strictly scope-based mutex ownership wrapper (class template)
scoped_lock (C++17) | deadlock-avoiding RAII wrapper for multiple mutexes (class template)
unique_lock (C++11) | implements movable mutex ownership wrapper (class template)
shared_lock (C++14) | implements movable shared mutex ownership wrapper (class template)
defer_lock_t try_to_lock_t adopt_lock_t (C++11)(C++11)(C++11) | tag type used to specify locking strategy (class)
defer_lock try_to_lock adopt_lock (C++11)(C++11)(C++11) | tag constants used to specify locking strategy (constant)
##### Generic locking algorithms
try_lock (C++11) | attempts to obtain ownership of mutexes via repeated calls to `try_lock` (function template)
lock (C++11) | locks specified mutexes, blocks if any are unavailable (function template)
##### Call once
once_flag (C++11) | helper object to ensure that `call_once` invokes the function only once (class)
call_once (C++11) | invokes a function only once even if called from multiple threads (function template)

### Condition variables

A condition variable is a synchronization primitive that allows multiple threads to communicate with each other. It allows some number of threads to wait (possibly with a timeout) for notification from another thread that they may proceed. A condition variable is always associated with a mutex.

Defined in header `<condition_variable>`
condition_variable (C++11) | provides a condition variable associated with a std::unique_lock (class)
condition_variable_any (C++11) | provides a condition variable associated with any lock type (class)
notify_all_at_thread_exit (C++11) | schedules a call to `notify_all` to be invoked when this thread is completely finished (function)
cv_status (C++11) | lists the possible results of timed waits on condition variables (enum)

### Semaphores A semaphore is a lightweight synchronization primitive used to constrain concurrent access to a shared resource. When either would suffice, a semaphore can be more efficient than a condition variable.
Defined in header `<semaphore>`
counting_semaphore (C++20) | semaphore that models a non-negative resource count (class template)
binary_semaphore (C++20) | semaphore that has only two states (typedef)
### Latches and Barriers Latches and barriers are thread coordination mechanisms that allow any number of threads to block until an expected number of threads arrive. A latch cannot be reused, while a barrier can be used repeatedly.
Defined in header `<latch>`
latch (C++20) | single-use thread barrier (class)
Defined in header `<barrier>`
barrier (C++20) | reusable thread barrier (class template)
| (since C++20)

### Futures

The standard library provides facilities to obtain values that are returned and to catch exceptions that are thrown by asynchronous tasks (i.e. functions launched in separate threads). These values are communicated in a shared state, in which the asynchronous task may write its return value or store an exception, and which may be examined, waited for, and otherwise manipulated by other threads that hold instances of std::future or std::shared_future that reference that shared state.

Defined in header `<future>`
promise (C++11) | stores a value for asynchronous retrieval (class template)
packaged_task (C++11) | packages a function to store its return value for asynchronous retrieval (class template)
future (C++11) | waits for a value that is set asynchronously (class template)
shared_future (C++11) | waits for a value (possibly referenced by other futures) that is set asynchronously (class template)
async (C++11) | runs a function asynchronously (potentially in a new thread) and returns a std::future that will hold the result (function template)
launch (C++11) | specifies the launch policy for std::async (enum)
future_status (C++11) | specifies the results of timed waits performed on std::future and std::shared_future (enum)
##### Future errors
future_error (C++11) | reports an error related to futures or promises (class)
future_category (C++11) | identifies the future error category (function)
future_errc (C++11) | identifies the future error codes (enum)

### See also

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/thread&oldid=142528"