Difference between revisions of "cpp/thread"

Latest revision as of 20:53, 8 November 2024

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

[edit] Threads

Threads enable programs to execute across several processor cores.

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

Cooperative cancellation

The components stop source, stop token, and stop callback can be used to asynchronously request that an operation stops execution in a timely manner, typically because the result is no longer required. Such a request is called a stop request.

These components specify the semantics of shared access to a stop state. Any object modeling any of these components that refer to the same stop state is an associated stop source, stop token, or stop callback, respectively.

The concepts stoppable-source, stoppable_token, and stoppable-callback-for specify the required syntax and model semantics of stop source, stop token, and stop callback, respectively.

(since C++26)

They are designed:

to cooperatively cancel the execution such as for std::jthread,
to interrupt std::condition_variable_any waiting functions,

to perform stopped completion of an asynchronous operation created by execution::connect,

(since C++26)

or for a custom execution 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 types
stop_token (C++20)	an interface for querying if a std::jthread cancellation request has been made (class) [edit]
never_stop_token (C++26)	provides a stop token interface that a stop is never possible nor requested (class) [edit]
inplace_stop_token (C++26)	a stop token that references stop state of its associated `std::inplace_stop_source` object (class) [edit]
Stop source types
stop_source (C++20)	class representing a request to stop one or more std::jthreads (class) [edit]
inplace_stop_source (C++26)	a `stoppable-source` that is the sole owner of the stop state (class) [edit]
Stop callback types
stop_callback (C++20)	an interface for registering callbacks on std::jthread cancellation (class template) [edit]
inplace_stop_callback (C++26)	a stop callback for `std::inplace_stop_token` (class template) [edit]
stop_callback_for_t (C++26)	obtains the callback type for a given stop token type (alias template)[edit]
Concepts
stoppable_token (C++26)	specifies the basic interface of stop tokens which allows queries for stop requests and whether the stop request is possible (concept) [edit]
unstoppable_token (C++26)	specifies a stop token that does not allow stopping (concept) [edit]
stoppable-source (C++26)	specifies that a type is a factory for associated stop tokens and a stop request can be made upon it (exposition-only concept*)[edit]
stoppable-callback-for (C++26)	specifies an interface for registering callbacks with a given stop token type (exposition-only concept*)[edit]

(since C++20)

[edit] Cache size access

Defined in header `<new>`
hardware_destructive_interference_sizehardware_constructive_interference_size (C++17)	min offset to avoid false sharing max offset to promote true sharing (constant) [edit]

[edit] 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, floating-point,(since C++20) and pointer types (class template) [edit]
atomic_ref (C++20)	provides atomic operations on non-atomic objects (class template) [edit]
Operations on atomic types
atomic_is_lock_free (C++11)	checks if the atomic type's operations are lock-free (function template) [edit]
atomic_storeatomic_store_explicit (C++11)(C++11)	atomically replaces the value of the atomic object with a non-atomic argument (function template) [edit]
atomic_loadatomic_load_explicit (C++11)(C++11)	atomically obtains the value stored in an atomic object (function template) [edit]
atomic_exchangeatomic_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) [edit]
atomic_compare_exchange_weakatomic_compare_exchange_weak_explicitatomic_compare_exchange_strongatomic_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) [edit]
atomic_fetch_addatomic_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) [edit]
atomic_fetch_subatomic_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) [edit]
atomic_fetch_andatomic_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) [edit]
atomic_fetch_oratomic_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) [edit]
atomic_fetch_xoratomic_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) [edit]
atomic_fetch_maxatomic_fetch_max_explicit (C++26)(C++26)	replaces the atomic object with the result of std::max with a non-atomic argument and obtains the previous value of the atomic (function template) [edit]
atomic_fetch_minatomic_fetch_min_explicit (C++26)(C++26)	replaces the atomic object with the result of std::min with a non-atomic argument and obtains the previous value of the atomic (function template) [edit]
atomic_waitatomic_wait_explicit (C++20)(C++20)	blocks the thread until notified and the atomic value changes (function template) [edit]
atomic_notify_one (C++20)	notifies a thread blocked in atomic_wait (function template) [edit]
atomic_notify_all (C++20)	notifies all threads blocked in atomic_wait (function template) [edit]
Flag type and operations
atomic_flag (C++11)	the lock-free boolean atomic type (class) [edit]
atomic_flag_test_and_setatomic_flag_test_and_set_explicit (C++11)(C++11)	atomically sets the flag to true and returns its previous value (function) [edit]
atomic_flag_clearatomic_flag_clear_explicit (C++11)(C++11)	atomically sets the value of the flag to false (function) [edit]
atomic_flag_testatomic_flag_test_explicit (C++20)(C++20)	atomically returns the value of the flag (function) [edit]
atomic_flag_waitatomic_flag_wait_explicit (C++20)(C++20)	blocks the thread until notified and the flag changes (function) [edit]
atomic_flag_notify_one (C++20)	notifies a thread blocked in atomic_flag_wait (function) [edit]
atomic_flag_notify_all (C++20)	notifies all threads blocked in atomic_flag_wait (function) [edit]
Initialization
atomic_init (C++11)(deprecated in C++20)	non-atomic initialization of a default-constructed atomic object (function template) [edit]
ATOMIC_VAR_INIT (C++11)(deprecated in C++20)	constant initialization of an atomic variable of static storage duration (function macro) [edit]
ATOMIC_FLAG_INIT (C++11)	initializes an std::atomic_flag to false (macro constant) [edit]
Memory synchronization ordering
memory_order (C++11)	defines memory ordering constraints for the given atomic operation (enum) [edit]
kill_dependency (C++11)	removes the specified object from the std::memory_order_consume dependency tree (function template) [edit]
atomic_thread_fence (C++11)	generic memory order-dependent fence synchronization primitive (function) [edit]
atomic_signal_fence (C++11)	fence between a thread and a signal handler executed in the same thread (function) [edit]
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) [edit]

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

[edit] 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) [edit]
condition_variable_any (C++11)	provides a condition variable associated with any lock type (class) [edit]
notify_all_at_thread_exit (C++11)	schedules a call to `notify_all` to be invoked when this thread is completely finished (function) [edit]
cv_status (C++11)	lists the possible results of timed waits on condition variables (enum) [edit]

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) [edit]
binary_semaphore (C++20)	semaphore that has only two states (typedef) [edit]

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) [edit]
Defined in header `<barrier>`
barrier (C++20)	reusable thread barrier (class template) [edit]

(since C++20)

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

Safe Reclamation

Safe-reclamation techniques are most frequently used to straightforwardly resolve access-deletion races.

Read-Copy-Update Mechanism
Defined in header `<rcu>`
rcu_obj_base (C++26)	allows an object to be protected by RCU (class template) [edit]
rcu_domain (C++26)	provides regions of RCU protection (class) [edit]
rcu_default_domain (C++26)	returns a reference to a static-duration object of type `std::rcu_domain` (function) [edit]
rcu_synchronize (C++26)	blocks until a protection region unlocks on a RCU domain (function) [edit]
rcu_barrier (C++26)	may evaluate scheduled operations on a RCU domain and blocks until all preceding evaluations are complete (function) [edit]
rcu_retire (C++26)	schedules the evaluation of a specified function on a RCU domain, potentially allocating memory, and invoking scheduled evaluations (function template) [edit]
Hazard Pointers
Defined in header `<hazard_pointer>`
hazard_pointer_obj_base (C++26)	allows an object to be hazard-protectable (class template) [edit]
hazard_pointer (C++26)	single-writer multi-reader pointer that can be owned by at most one thread at any point of time (class) [edit]
make_hazard_pointer (C++26)	constructs a hazard pointer (function) [edit]

(since C++26)

[edit] See also

C documentation for Concurrency support library

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.com

Namespaces

Variants

Views

Actions

Difference between revisions of "cpp/thread"

Latest revision as of 20:53, 8 November 2024

Contents

[edit] Threads

Functions managing the current thread

Cooperative cancellation

Stop token types

Stop source types

Stop callback types

Concepts

[edit] Cache size access

[edit] Atomic operations

Atomic types

Operations on atomic types

Flag type and operations

Initialization

Memory synchronization ordering

C compatibility macros

[edit] Mutual exclusion

Generic mutex management

Generic locking algorithms

Call once

[edit] Condition variables

Semaphores

Latches and Barriers

[edit] Futures

Future errors

Safe Reclamation

Read-Copy-Update Mechanism

Hazard Pointers

[edit] See also

Navigation

Toolbox

@@ Line 1: / Line 1: @@
-{{title|Thread support library}}
+{{title|Concurrency support library {{mark since c++11}}}}
-{{cpp/thread/sidebar}}
+{{cpp/thread/navbar}}
+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.
-Threads enable the program to execute across several processor cores.
+{{dsc begin}}
+{{dsc header|thread}}
+{{dsc inc|cpp/thread/dsc thread}}
+{{dsc inc|cpp/thread/dsc jthread}}
+{{dsc h2|Functions managing the current thread}}
+{{dsc namespace|this_thread}}
+{{dsc inc|cpp/thread/dsc yield}}
+{{dsc inc|cpp/thread/dsc get_id}}
+{{dsc inc|cpp/thread/dsc sleep_for}}
+{{dsc inc|cpp/thread/dsc sleep_until}}
+{{dsc end}}
-{{dcl list begin}}
+{{rrev|since=c++20|
-{{dcl list header | thread}}
+===Cooperative cancellation===
-{{dcl list template | cpp/thread/dcl list thread}}
+The components ''stop source'', ''stop token'', and ''stop callback'' can be used to asynchronously request that an operation stops execution in a timely manner, typically because the result is no longer required. Such a request is called a ''stop request''.
-{{dcl list h2 | Functions managing the current thread}}
-{{dcl list namespace | this_thread}}
-{{dcl list template | cpp/thread/dcl list yield}}
-{{dcl list template | cpp/thread/dcl list get_id}}
-{{dcl list template | cpp/thread/dcl list sleep_for}}
-{{dcl list template | cpp/thread/dcl list sleep_until}}
-{{dcl list end}}
-===Mutual exclusion===
+These components specify the semantics of shared access to a ''stop state''. Any object modeling any of these components that refer to the same stop state is an associated stop source, stop token, or stop callback, respectively.
-Mutual exclusion algorithms restrict access to a shared resource so that only one thread can access it at a time. This allows to avoid data races and to implement synchronization between threads.
+{{rrev|since=c++26|
+The concepts {{lconcept|stoppable-source}}, {{lconcept|stoppable_token}}, and {{lconcept|stoppable-callback-for}} specify the required syntax and model semantics of stop source, stop token, and stop callback, respectively.
+}}
-{{dcl list begin}}
+They are designed:
-{{dcl list header | mutex}}
+* to cooperatively cancel the execution such as for {{lc|std::jthread}},
-{{dcl list template | cpp/thread/dcl list mutex}}
+* to interrupt {{lc|std::condition_variable_any}} waiting functions,
-{{dcl list template | cpp/thread/dcl list timed_mutex}}
+{{rrev|since=c++26|* to perform stopped completion of an asynchronous operation created by {{lc|execution::connect}},}}
-{{dcl list template | cpp/thread/dcl list recursive_mutex}}
+* or for a custom execution management implementation.
-{{dcl list template | cpp/thread/dcl list recursive_timed_mutex}}
+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.
-{{dcl list h2 | Generic mutex management}}
+{{dsc begin}}
-{{dcl list template | cpp/thread/dcl list lock_guard}}
+{{dsc header|stop_token}}
-{{dcl list template | cpp/thread/dcl list unique_lock}}
+{{dsc h2|Stop token types}}
-{{dcl list template | cpp/thread/dcl list lock_tag_t}}
+{{dsc inc|cpp/thread/dsc stop_token}}
-{{dcl list template | cpp/thread/dcl list lock_tag}}
+{{dsc inc|cpp/thread/dsc never_stop_token}}
+{{dsc inc|cpp/thread/dsc inplace_stop_token}}
+{{dsc h2|Stop source types}}
+{{dsc inc|cpp/thread/dsc stop_source}}<!--include nostopstate_t inside as helper-->
+{{dsc inc|cpp/thread/dsc inplace_stop_source}}
+{{dsc h2|Stop callback types}}
+{{dsc inc|cpp/thread/dsc stop_callback}}
+{{dsc inc|cpp/thread/dsc inplace_stop_callback}}
+{{dsc inc|cpp/thread/dsc stop_callback_for_t}}
+{{dsc h2|Concepts}}
+{{dsc inc|cpp/thread/dsc stoppable_token}}
+{{dsc inc|cpp/thread/dsc unstoppable_token}}
+{{dsc inc|cpp/thread/dsc stoppable_source}}
+{{dsc inc|cpp/thread/dsc stoppable_callback_for}}
+{{dsc end}}
+}}
-{{dcl list h2 | Generic locking algorithms}}
+===Cache size access===
-{{dcl list template | cpp/thread/dcl list try_lock}}
+{{dsc begin}}
-{{dcl list template | cpp/thread/dcl list lock}}
+{{dsc header|new}}
+{{dsc inc|cpp/thread/dsc hardware_destructive_interference_size}}
+{{dsc end}}
-{{dcl list h2 | Call once}}
+===Atomic operations===
-{{dcl list template | cpp/thread/dcl list once_flag}}
+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 [[cpp/language/memory_model#Threads_and_data_races|free of data races]].
-{{dcl list template | cpp/thread/dcl list call_once}}
-{{dcl list end}}
+{{rrev|since=c++23|
+Neither the {{tt|_Atomic}} macro, nor any of the non-macro global namespace declarations are provided by any C++ standard library header other than {{tt|<stdatomic.h>}}.
+}}
+{{dsc begin}}
+{{dsc header|atomic}}
+{{dsc h2|Atomic types}}
+{{dsc inc|cpp/atomic/dsc atomic}}
+{{dsc inc|cpp/atomic/dsc atomic_ref}}
+{{dsc h2|Operations on atomic types}}
+{{dsc inc|cpp/atomic/dsc atomic_is_lock_free}}
+{{dsc inc|cpp/atomic/dsc atomic_store}}
+{{dsc inc|cpp/atomic/dsc atomic_load}}
+{{dsc inc|cpp/atomic/dsc atomic_exchange}}
+{{dsc inc|cpp/atomic/dsc atomic_compare_exchange}}
+{{dsc inc|cpp/atomic/dsc atomic_fetch_add}}
+{{dsc inc|cpp/atomic/dsc atomic_fetch_sub}}
+{{dsc inc|cpp/atomic/dsc atomic_fetch_and}}
+{{dsc inc|cpp/atomic/dsc atomic_fetch_or}}
+{{dsc inc|cpp/atomic/dsc atomic_fetch_xor}}
+{{dsc inc|cpp/atomic/dsc atomic_fetch_max}}
+{{dsc inc|cpp/atomic/dsc atomic_fetch_min}}
+{{dsc inc|cpp/atomic/dsc atomic_wait}}
+{{dsc inc|cpp/atomic/dsc atomic_notify_one}}
+{{dsc inc|cpp/atomic/dsc atomic_notify_all}}
+{{dsc h2|Flag type and operations}}
+{{dsc inc|cpp/atomic/dsc atomic_flag}}
+{{dsc inc|cpp/atomic/dsc atomic_flag_test_and_set}}
+{{dsc inc|cpp/atomic/dsc atomic_flag_clear}}
+{{dsc inc|cpp/atomic/dsc atomic_flag_test}}
+{{dsc inc|cpp/atomic/dsc atomic_flag_wait}}
+{{dsc inc|cpp/atomic/dsc atomic_flag_notify_one}}
+{{dsc inc|cpp/atomic/dsc atomic_flag_notify_all}}
+{{dsc h2|Initialization}}
+{{dsc inc|cpp/atomic/dsc atomic_init}}
+{{dsc inc|cpp/atomic/dsc ATOMIC_VAR_INIT}}
+{{dsc inc|cpp/atomic/dsc ATOMIC_FLAG_INIT}}
+{{dsc h2|Memory synchronization ordering}}
+{{dsc inc|cpp/atomic/dsc memory_order}}
+{{dsc inc|cpp/atomic/dsc kill_dependency}}
+{{dsc inc|cpp/atomic/dsc atomic_thread_fence}}
+{{dsc inc|cpp/atomic/dsc atomic_signal_fence}}
+{{dsc header|stdatomic.h}}
+{{dsc h2|C compatibility macros}}
+{{dsc inc|cpp/atomic/dsc _Atomic}}
+{{dsc end}}
+===Mutual exclusion===
+Mutual exclusion algorithms prevent multiple threads from simultaneously accessing shared resources. This prevents data races and provides support for synchronization between threads.
+{{dsc begin}}
+{{dsc header|mutex}}
+{{dsc inc|cpp/thread/dsc mutex}}
+{{dsc inc|cpp/thread/dsc timed_mutex}}
+{{dsc inc|cpp/thread/dsc recursive_mutex}}
+{{dsc inc|cpp/thread/dsc recursive_timed_mutex}}
+{{dsc header|shared_mutex}}
+{{dsc inc|cpp/thread/dsc shared_mutex}}
+{{dsc inc|cpp/thread/dsc shared_timed_mutex}}
+{{dsc h2|Generic mutex management}}
+{{dsc header|mutex}}
+{{dsc inc|cpp/thread/dsc lock_guard}}
+{{dsc inc|cpp/thread/dsc scoped_lock}}
+{{dsc inc|cpp/thread/dsc unique_lock}}
+{{dsc inc|cpp/thread/dsc shared_lock}}
+{{dsc inc|cpp/thread/dsc lock_tag}}
+{{dsc h2|Generic locking algorithms}}
+{{dsc inc|cpp/thread/dsc try_lock}}
+{{dsc inc|cpp/thread/dsc lock}}
+{{dsc h2|Call once}}
+{{dsc inc|cpp/thread/dsc once_flag}}
+{{dsc inc|cpp/thread/dsc call_once}}
+{{dsc end}}
 ===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.
-A condition variable is a synchronization primitive which implements a list of threads that are waiting until another thread notifies one or all of the waiting threads that they may proceed, until a timeout expires, or until a spurious wakeup occurs. A condition variable is always associated with a mutex.
+{{dsc begin}}
+{{dsc header|condition_variable}}
+{{dsc inc|cpp/thread/dsc condition_variable}}
+{{dsc inc|cpp/thread/dsc condition_variable_any}}
+{{dsc inc|cpp/thread/dsc notify_all_at_thread_exit}}
+{{dsc inc|cpp/thread/dsc cv_status}}
+{{dsc end}}
-{{dcl list begin}}
+{{rrev|since=c++20|
-{{dcl list class | cpp/thread/condition_variable | provides a condition variable assocaited with std::unique_lock | notes={{mark c++11}}}}
+===Semaphores===
-{{dcl list class | cpp/thread/condition_variable_any | provides a condition varibale associated with any lock type | notes={{mark c++11}}}}
+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.
-{{dcl list fun   | cpp/thread/notify_all_at_thread_exit | schedules a call to notify_all to be invoked when this thread exits | notes={{mark c++11}}}}
+{{dsc begin}}
-{{dcl list enum | cpp/thread/cv_status | lists the possible results of timed waits on condition variables | notes={{mark c++11}}}}
+{{dsc header|semaphore}}
-{{dcl list end}}
+{{dsc inc|cpp/thread/dsc counting_semaphore}}
+{{dsc inc|cpp/thread/dsc binary_semaphore}}
+{{dsc end}}
+===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.
+{{dsc begin}}
+{{dsc header|latch}}
+{{dsc inc|cpp/thread/dsc latch}}
+{{dsc header|barrier}}
+{{dsc inc|cpp/thread/dsc barrier}}
+{{dsc end}}
+}}
 ===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 {{lc|std::future}} or {{lc|std::shared_future}} that reference that shared state.
+{{dsc begin}}
+{{dsc header|future}}
+{{dsc inc|cpp/thread/dsc promise}}
+{{dsc inc|cpp/thread/dsc packaged_task}}
+{{dsc inc|cpp/thread/dsc future}}
+{{dsc inc|cpp/thread/dsc shared_future}}
+{{dsc inc|cpp/thread/dsc async}}
+{{dsc inc|cpp/thread/dsc launch}}
+{{dsc inc|cpp/thread/dsc future_status}}
+{{dsc h2|Future errors}}
+{{dsc inc|cpp/thread/dsc future_error}}
+{{dsc inc|cpp/thread/dsc future_category}}
+{{dsc inc|cpp/thread/dsc future_errc}}
+{{dsc end}}
+{{rrev|since=c++26|
+===Safe Reclamation===
+Safe-reclamation techniques are most frequently used to straightforwardly resolve access-deletion races.
+{{dsc begin}}
+{{dsc h2|Read-Copy-Update Mechanism}}
+{{dsc header|rcu}}
+{{dsc inc|cpp/thread/dsc rcu_obj_base}}
+{{dsc inc|cpp/thread/dsc rcu_domain}}
+{{dsc inc|cpp/thread/dsc rcu_default_domain}}
+{{dsc inc|cpp/thread/dsc rcu_synchronize}}
+{{dsc inc|cpp/thread/dsc rcu_barrier}}
+{{dsc inc|cpp/thread/dsc rcu_retire}}
+{{dsc h2|Hazard Pointers}}
+{{dsc header|hazard_pointer}}
+{{dsc inc|cpp/thread/dsc hazard_pointer_obj_base}}
+{{dsc inc|cpp/thread/dsc hazard_pointer}}
+{{dsc inc|cpp/thread/dsc make_hazard_pointer}}
+{{dsc end}}
+}}
-{{todo}}
+===See also===
+{{dsc begin}}
+{{dsc see c|c/thread|Concurrency support library|nomono=true}}
+{{dsc end}}
-{{dcl list begin}}
+{{langlinks|ar|de|es|fr|it|ja|pt|ru|zh}}
-{{dcl list header | future}}
-{{dcl list tclass | cpp/thread/promise | stores a value for asynchronous retrieval | notes={{mark c++11}}}}
-{{dcl list tclass | cpp/thread/packaged_task | packages a function to store its return value for asynchronous retrieval | notes={{mark c++11}}}}
-{{dcl list tclass | cpp/thread/future | waits for a value that is set asynchronously | notes={{mark c++11}}}}
-{{dcl list tclass | cpp/thread/shared_future | waits for a value that is set asynchronously. The internal state is shared among several objects | notes={{mark c++11}}}}
-{{dcl list tfun | cpp/thread/async | provides a facility to launch a function in a new thread and acquire its return value asynchronously | notes={{mark c++11}}}}
-{{dcl list end}}