\rSec0[thread]{Concurrency support library}

\rSec1[thread.general]{General}

The following subclauses describe components to create and manage

threads\iref{intro.multithread}, perform mutual exclusion, and communicate conditions

and values

between threads, as summarized in \tref{thread.summary}.

\begin{libsumtab}{Concurrency support library summary}{thread.summary}

\ref{thread.req} & Requirements & \\ \rowsep

\ref{thread.stoptoken}& Stop tokens & \tcode{<stop_token>} \\ \rowsep

\ref{thread.threads} & Threads & \tcode{<thread>} \\ \rowsep

\ref{atomics} & Atomic operations &

\tcode{<atomic>}, \tcode{<stdatomic.h>} \\ \rowsep

\ref{thread.mutex} & Mutual exclusion &

\tcode{<mutex>}, \tcode{<shared_mutex>} \\ \rowsep

\ref{thread.condition}& Condition variables & \tcode{<condition_variable>} \\ \rowsep

\ref{thread.sema} & Semaphores & \tcode{<semaphore>} \\ \rowsep

\ref{thread.coord} & Coordination types & \tcode{<latch>}, \tcode{<barrier>} \\ \rowsep

\ref{futures} & Futures & \tcode{<future>} \\ \rowsep

\ref{saferecl} & Safe reclamation & \tcode{<rcu>}, \tcode{<hazard_pointer>} \\

\end{libsumtab}

\rSec1[thread.req]{Requirements}

\rSec2[thread.req.paramname]{Template parameter names}

Throughout this Clause, the names of template parameters are used to express type

requirements.

\tcode{Predicate} is a function object type\iref{function.objects}.

Let \tcode{pred} denote an lvalue of type \tcode{Predicate}.

Then the expression \tcode{pred()} shall be well-formed and

the type \tcode{decltype(pred())} shall model

\exposconcept{boolean-testable}\iref{concept.booleantestable}.

The return value of \tcode{pred()}, converted to \tcode{bool},

yields \tcode{true} if the corresponding test condition is satisfied, and

\tcode{false} otherwise.

If a template parameter is named \tcode{Clock},

the corresponding template argument shall be a type \tcode{C}

that meets the \oldconcept{Clock} requirements\iref{time.clock.req};

the program is ill-formed if \tcode{is_clock_v<C>} is \tcode{false}.

\rSec2[thread.req.exception]{Exceptions}

Some functions described in this Clause are specified to throw exceptions of type

\tcode{system_error}\iref{syserr.syserr}. Such exceptions are thrown if

any of the function's error conditions is detected or

a call to

an operating system or other underlying API results in an error that prevents the

library function from

meeting its specifications. Failure to allocate storage is reported as described

in~\ref{res.on.exception.handling}.

\begin{example}

Consider a function in this Clause that is specified to throw exceptions of type

\tcode{system_error} and specifies error conditions that include

\tcode{operation_not_permitted} for a thread that does not have the privilege to

perform the operation. Assume that, during the execution of this function, an \tcode{errno}

of \tcode{EPERM} is reported by a POSIX API call used by the implementation. Since POSIX

specifies an \tcode{errno} of \tcode{EPERM} when ``the caller does not have the privilege

to perform the operation'', the implementation maps \tcode{EPERM} to an

\tcode{error_condition} of \tcode{operation_not_permitted}\iref{syserr} and an exception

of type \tcode{system_error} is thrown.

\end{example}

The \tcode{error_code} reported by such an exception's \tcode{code()} member function

compares equal to one of the conditions specified in the function's error condition

element.

\rSec2[thread.req.native]{Native handles}

Several classes described in this Clause have members \tcode{native_handle_type} and

\tcode{native_handle}. The presence of these members and their semantics is

\impldef{presence and meaning of \tcode{native_handle_type} and \tcode{native_handle}}.

\begin{note}

These members allow implementations to provide access

to implementation details. Their names are specified to facilitate portable compile-time

detection. Actual use of these members is inherently non-portable.

\end{note}

\rSec2[thread.req.timing]{Timing specifications}

Several functions described in this Clause take an argument to specify a timeout. These

timeouts are specified as either a \tcode{duration} or a \tcode{time_point} type as

specified in~\ref{time}.

Implementations necessarily have some delay in returning from a timeout. Any overhead in

interrupt response, function return, and scheduling induces a ``quality of implementation''

delay, expressed as duration $D_i$. Ideally, this delay would be zero. Further, any contention for

processor and memory resources induces a ``quality of management'' delay, expressed as duration

$D_m$. The delay durations may vary from timeout to timeout, but in all cases shorter is better.

The functions whose names end in \tcode{_for} take an argument that

specifies a duration. These functions produce relative timeouts. Implementations

should use a steady clock to measure time for these functions.

\begin{footnote}

Implementations for which standard time units are meaningful will typically

have a steady clock within their hardware implementation.

\end{footnote}

Given a duration

argument $D_t$, the real-time duration of the timeout is $D_t + D_i + D_m$.

The functions whose names end in \tcode{_until} take an argument that specifies a time

point. These functions produce absolute timeouts. Implementations should use the clock

specified in the time point to measure time for these functions. Given a clock time point

argument $C_t$, the clock time point of the return from timeout should be $C_t + D_i + D_m$

when the clock is not adjusted during the timeout. If the clock is adjusted to the time $C_a$

during the timeout, the behavior should be as follows:

\begin{itemize}

If $C_a > C_t$, the waiting function should wake as soon as possible, i.e., $C_a + D_i + D_m$,

since the timeout is already satisfied.

This specification may result in the total

duration of the wait decreasing when measured against a steady clock.

If $C_a \leq C_t$, the waiting function should not time out until \tcode{Clock::now()} returns a

time $C_n \geq C_t$, i.e., waking at $C_t + D_i + D_m$.

\begin{note}

When the clock is adjusted

backwards, this specification can result in the total duration of the wait increasing when

measured against a steady clock. When the clock is adjusted forwards, this specification can

result in the total duration of the wait decreasing when measured against a steady clock.

\end{note}

\end{itemize}

An implementation returns from such a timeout at any point from the time specified above to

the time it would return from a steady-clock relative timeout on the difference between $C_t$

and the time point of the call to the \tcode{_until} function.

Implementations

should decrease the duration of the wait when the clock is adjusted forwards.

\begin{note}

If the clock is not synchronized with a steady clock, e.g., a CPU time clock, these

timeouts can fail to provide useful functionality.

\end{note}

The resolution of timing provided by an implementation depends on both operating system

and hardware. The finest resolution provided by an implementation is called the

\term{native resolution}.

Implementation-provided clocks that are used for these functions meet the

\oldconcept{TrivialClock} requirements\iref{time.clock.req}.

A function that takes an argument which specifies a timeout will throw if,

during its execution, a clock, time point, or time duration throws an exception.

Such exceptions are referred to as \term{timeout-related exceptions}.

\begin{note}

Instantiations of clock, time point and duration types supplied by

the implementation as specified in~\ref{time.clock} do not throw exceptions.

\end{note}

\rSec2[thread.req.lockable]{Requirements for \oldconcept{Lockable} types}

\rSec3[thread.req.lockable.general]{In general}

An \defn{execution agent} is an entity such as a thread that may perform work in parallel with

other execution agents.

\begin{note}

Implementations or users can introduce other kinds of

agents such as processes or thread-pool tasks.

\end{note}

The calling agent is determined by

context, e.g., the calling thread that contains the call, and so on.

\begin{note}

Some lockable objects are ``agent oblivious'' in that they work for any

execution agent model because they do not determine or store the agent's ID (e.g., an

ordinary spin lock).

\end{note}

The standard library templates \tcode{unique_lock}\iref{thread.lock.unique},

\tcode{shared_lock}\iref{thread.lock.shared},

\tcode{scoped_lock}\iref{thread.lock.scoped},

\tcode{lock_guard}\iref{thread.lock.guard}, \tcode{lock},

\tcode{try_lock}\iref{thread.lock.algorithm}, and

\tcode{condition_variable_any}\iref{thread.condition.condvarany} all operate on user-supplied

lockable objects. The \oldconcept{BasicLockable} requirements, the \oldconcept{Lockable} requirements,

the \oldconcept{TimedLockable} requirements,

the \oldconcept{SharedLockable} requirements, and

the \oldconcept{SharedTimedLock\-able} requirements

list the requirements imposed by these library types

in order to acquire or release ownership of a \tcode{lock} by a given execution agent.

\begin{note}

The nature of any lock ownership and any synchronization it entails are not part

of these requirements.

\end{note}

A lock on an object \tcode{m} is said to be

\begin{itemize}

a \defnadj{non-shared}{lock} if it is acquired by a call to

\tcode{lock},

\tcode{try_lock},

\tcode{try_lock_for}, or

\tcode{try_lock_until} on \tcode{m}, or

a \defnadj{shared}{lock} if it is acquired by a call to

\tcode{lock_shared},

\tcode{try_lock_shared},

\tcode{try_lock_shared_for}, or

\tcode{try_lock_shared_until} on \tcode{m}.

\end{itemize}

\begin{note}

Only the method of lock acquisition is considered;

the nature of any lock ownership is not part of these definitions.

\end{note}

\rSec3[thread.req.lockable.basic]{\oldconcept{BasicLockable} requirements}

A type \tcode{L} meets the \oldconcept{BasicLockable} requirements if the following expressions are

well-formed and have the specified semantics (\tcode{m} denotes a value of type \tcode{L}).

\begin{itemdecl}

m.lock()

\end{itemdecl}

\begin{itemdescr}

\indextext{block (execution)}%

Blocks until a lock can be acquired for the current execution agent. If an exception

is thrown then a lock shall not have been acquired for the current execution agent.

\end{itemdescr}

\begin{itemdecl}

m.unlock()

\end{itemdecl}

\begin{itemdescr}

The current execution agent holds a non-shared lock on \tcode{m}.

Releases a non-shared lock on \tcode{m} held by the current execution agent.

Nothing.

\end{itemdescr}

\rSec3[thread.req.lockable.req]{\oldconcept{Lockable} requirements}

A type \tcode{L} meets the \oldconcept{Lockable} requirements if it meets the \oldconcept{BasicLockable}

requirements and the following expressions are well-formed and have the specified semantics

(\tcode{m} denotes a value of type \tcode{L}).

\begin{itemdecl}

m.try_lock()

\end{itemdecl}

\begin{itemdescr}

Attempts to acquire a lock for the current execution agent without blocking. If an

exception is thrown then a lock shall not have been acquired for the current execution agent.

\returntype \tcode{bool}.

\tcode{true} if the lock was acquired, otherwise \tcode{false}.

\end{itemdescr}

\rSec3[thread.req.lockable.timed]{\oldconcept{TimedLockable} requirements}

A type \tcode{L} meets the \oldconcept{TimedLockable} requirements if it meets the \oldconcept{Lockable}

requirements and the following expressions are well-formed and have the specified semantics

(\tcode{m} denotes a value of type \tcode{L}, \tcode{rel_time} denotes a value of an

instantiation of \tcode{duration}\iref{time.duration}, and \tcode{abs_time} denotes a value

of an instantiation of \tcode{time_point}\iref{time.point}).

\begin{itemdecl}

m.try_lock_for(rel_time)

\end{itemdecl}

\begin{itemdescr}

Attempts to acquire a lock for the current execution agent within the relative

timeout\iref{thread.req.timing} specified by \tcode{rel_time}. The function will not return

within the timeout specified by \tcode{rel_time} unless it has obtained a lock on \tcode{m}

for the current execution agent. If an exception is thrown then a lock has not been

acquired for the current execution agent.

\returntype \tcode{bool}.

\tcode{true} if the lock was acquired, otherwise \tcode{false}.

\end{itemdescr}

\begin{itemdecl}

m.try_lock_until(abs_time)

\end{itemdecl}

\begin{itemdescr}

Attempts to acquire a lock for the current execution agent before the absolute

timeout\iref{thread.req.timing} specified by \tcode{abs_time}. The function will not return

before the timeout specified by \tcode{abs_time} unless it has obtained a lock on \tcode{m} for

the current execution agent. If an exception is thrown then a lock has not been acquired

for the current execution agent.

\returntype \tcode{bool}.

\tcode{true} if the lock was acquired, otherwise \tcode{false}.

\end{itemdescr}

\rSec3[thread.req.lockable.shared]{\oldconcept{SharedLockable} requirements}

A type \tcode{L} meets the \oldconcept{SharedLockable} requirements if

the following expressions are well-formed, have the specified semantics, and

the expression \tcode{m.try_lock_shared()} has type \tcode{bool}

(\tcode{m} denotes a value of type \tcode{L}):

\begin{itemdecl}

m.lock_shared()

\end{itemdecl}

\begin{itemdescr}

Blocks until a lock can be acquired for the current execution agent.

If an exception is thrown then a lock shall not have been acquired for

the current execution agent.

\end{itemdescr}

\begin{itemdecl}

m.try_lock_shared()

\end{itemdecl}

\begin{itemdescr}

Attempts to acquire a lock for the current execution agent without blocking.

If an exception is thrown then a lock shall not have been acquired for

the current execution agent.

\tcode{true} if the lock was acquired, \tcode{false} otherwise.

\end{itemdescr}

\begin{itemdecl}

m.unlock_shared()

\end{itemdecl}

\begin{itemdescr}

The current execution agent holds a shared lock on \tcode{m}.

Releases a shared lock on \tcode{m} held by the current execution agent.

Nothing.

\end{itemdescr}

\rSec3[thread.req.lockable.shared.timed]{\oldconcept{SharedTimedLockable} requirements}

A type \tcode{L} meets the \oldconcept{SharedTimedLockable} requirements if

it meets the \oldconcept{SharedLockable} requirements, and

the following expressions are well-formed, have type \tcode{bool}, and

have the specified semantics

(\tcode{m} denotes a value of type \tcode{L},

\tcode{rel_time} denotes a value of a specialization of \tcode{chrono::duration}, and

\tcode{abs_time} denotes a value of a specialization of \tcode{chrono::time_point}).

\begin{itemdecl}

m.try_lock_shared_for(rel_time)

\end{itemdecl}

\begin{itemdescr}

Attempts to acquire a lock for the current execution agent within

the relative timeout\iref{thread.req.timing} specified by \tcode{rel_time}.

The function will not return within the timeout specified by \tcode{rel_time}

unless it has obtained a lock on \tcode{m} for the current execution agent.

If an exception is thrown then a lock has not been acquired for

the current execution agent.

\tcode{true} if the lock was acquired, \tcode{false} otherwise.

\end{itemdescr}

\begin{itemdecl}

m.try_lock_shared_until(abs_time)

\end{itemdecl}

\begin{itemdescr}

Attempts to acquire a lock for the current execution agent before

the absolute timeout\iref{thread.req.timing} specified by \tcode{abs_time}.

The function will not return before the timeout specified by \tcode{abs_time}

unless it has obtained a lock on \tcode{m} for the current execution agent.

If an exception is thrown then a lock has not been acquired for

the current execution agent.

\tcode{true} if the lock was acquired, \tcode{false} otherwise.

\end{itemdescr}

\rSec1[thread.stoptoken]{Stop tokens}

\rSec2[thread.stoptoken.intro]{Introduction}

Subclause \ref{thread.stoptoken} describes components that 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 \defn{stop request}.

\tcode{stop_source}, \tcode{stop_token}, and \tcode{stop_callback}

implement semantics of shared ownership of a \defn{stop state}.

Any \tcode{stop_source}, \tcode{stop_token}, or \tcode{stop_callback}

that shares ownership of the same stop state is an \defn{associated}

\tcode{stop_source}, \tcode{stop_token}, or \tcode{stop_callback}, respectively.

The last remaining owner of the stop state automatically

releases the resources associated with the stop state.

A \tcode{stop_token} can be passed to an operation which can either

\begin{itemize}

\item actively poll the token to check if there has been a stop request, or

\item register a callback using the \tcode{stop_callback} class template which

will be called in the event that a stop request is made.

\end{itemize}

A stop request made via a \tcode{stop_source} will be visible to all

associated \tcode{stop_token} and \tcode{stop_source} objects.

Once a stop request has been made it cannot be withdrawn

(a subsequent stop request has no effect).

Callbacks registered via a \tcode{stop_callback} object are called when

a stop request is first made by any associated \tcode{stop_source} object.

Calls to the functions \tcode{request_stop}, \tcode{stop_requested},

and \tcode{stop_possible}

do not introduce data races.

A call to \tcode{request_stop} that returns \tcode{true}

synchronizes with a call to \tcode{stop_requested}

on an associated \tcode{stop_token} or \tcode{stop_source} object

that returns \tcode{true}.

Registration of a callback synchronizes with the invocation of that callback.

\rSec2[thread.stoptoken.syn]{Header \tcode{<stop_token>} synopsis}

\indexheader{stop_token}%

\begin{codeblock}

namespace std {

// \ref{stoptoken}, class \tcode{stop_token}

class stop_token;

// \ref{stopsource}, class \tcode{stop_source}

class stop_source;

// no-shared-stop-state indicator

struct nostopstate_t {

explicit nostopstate_t() = default;

};

inline constexpr nostopstate_t nostopstate{};

// \ref{stopcallback}, class template \tcode{stop_callback}

template<class Callback>

class stop_callback;

}

\end{codeblock}

\rSec2[stoptoken]{Class \tcode{stop_token}}%

\indexlibraryglobal{stop_token}%

\rSec3[stoptoken.general]{General}

\indexlibraryglobal{stop_token}%

The class \tcode{stop_token} provides an interface for querying whether

a stop request has been made (\tcode{stop_requested})

or can ever be made (\tcode{stop_possible})

using an associated \tcode{stop_source} object\iref{stopsource}.

A \tcode{stop_token} can also be passed to a

\tcode{stop_callback}\iref{stopcallback} constructor

to register a callback to be called when a stop request has been made

from an associated \tcode{stop_source}.

\begin{codeblock}

namespace std {

class stop_token {

public:

// \ref{stoptoken.cons}, constructors, copy, and assignment

stop_token() noexcept;

stop_token(const stop_token&) noexcept;

stop_token(stop_token&&) noexcept;

stop_token& operator=(const stop_token&) noexcept;

stop_token& operator=(stop_token&&) noexcept;

~stop_token();

void swap(stop_token&) noexcept;

// \ref{stoptoken.mem}, stop handling

[[nodiscard]] bool stop_requested() const noexcept;

[[nodiscard]] bool stop_possible() const noexcept;

[[nodiscard]] friend bool operator==(const stop_token& lhs, const stop_token& rhs) noexcept;

friend void swap(stop_token& lhs, stop_token& rhs) noexcept;

};

}

\end{codeblock}

\rSec3[stoptoken.cons]{Constructors, copy, and assignment}

\indexlibraryctor{stop_token}%

\begin{itemdecl}

stop_token() noexcept;

\end{itemdecl}

\begin{itemdescr}

\tcode{stop_possible()} is \tcode{false} and

\tcode{stop_requested()} is \tcode{false}.

\begin{note}

Because the created \tcode{stop_token} object can never receive a stop request,

no resources are allocated for a stop state.

\end{note}

\end{itemdescr}

\indexlibraryctor{stop_token}%

\begin{itemdecl}

stop_token(const stop_token& rhs) noexcept;

\end{itemdecl}

\begin{itemdescr}

\tcode{*this == rhs} is \tcode{true}.

\begin{note}

\tcode{*this} and \tcode{rhs} share the ownership of the same stop state,

if any.

\end{note}

\end{itemdescr}

\indexlibraryctor{stop_token}%

\begin{itemdecl}

stop_token(stop_token&& rhs) noexcept;

\end{itemdecl}

\begin{itemdescr}

\tcode{*this} contains the value of \tcode{rhs}

prior to the start of construction

and \tcode{rhs.stop_possible()} is \tcode{false}.

\end{itemdescr}

\indexlibrarydtor{stop_token}%

\begin{itemdecl}

~stop_token();

\end{itemdecl}

\begin{itemdescr}

Releases ownership of the stop state, if any.

\end{itemdescr}

\indexlibrarymember{operator=}{stop_token}%

\begin{itemdecl}

stop_token& operator=(const stop_token& rhs) noexcept;

\end{itemdecl}

\begin{itemdescr}

Equivalent to: \tcode{stop_token(rhs).swap(*this)}.

\tcode{*this}.

\end{itemdescr}

\indexlibrarymember{operator=}{stop_token}%

\begin{itemdecl}

stop_token& operator=(stop_token&& rhs) noexcept;

\end{itemdecl}

\begin{itemdescr}

Equivalent to: \tcode{stop_token(std::move(rhs)).swap(*this)}.

\tcode{*this}.

\end{itemdescr}

\indexlibrarymember{swap}{stop_token}%

\begin{itemdecl}

void swap(stop_token& rhs) noexcept;

\end{itemdecl}

\begin{itemdescr}

Exchanges the values of \tcode{*this} and \tcode{rhs}.

\end{itemdescr}

\rSec3[stoptoken.mem]{Members}

\indexlibrarymember{stop_requested}{stop_token}%

\begin{itemdecl}

[[nodiscard]] bool stop_requested() const noexcept;

\end{itemdecl}

\begin{itemdescr}

\tcode{true} if \tcode{*this} has ownership of a stop state

that has received a stop request;

otherwise, \tcode{false}.

\end{itemdescr}

\indexlibrarymember{stop_possible}{stop_token}%

\begin{itemdecl}

[[nodiscard]] bool stop_possible() const noexcept;

\end{itemdecl}

\begin{itemdescr}

\tcode{false} if:

\begin{itemize}

\item \tcode{*this} does not have ownership of a stop state, or

\item a stop request was not made

and there are no associated \tcode{stop_source} objects;

\end{itemize}

otherwise, \tcode{true}.

\end{itemdescr}

\rSec3[stoptoken.nonmembers]{Non-member functions}

\indexlibrarymember{operator==}{stop_token}%

\begin{itemdecl}

[[nodiscard]] bool operator==(const stop_token& lhs, const stop_token& rhs) noexcept;

\end{itemdecl}

\begin{itemdescr}

\tcode{true} if \tcode{lhs} and \tcode{rhs} have ownership of the same stop state

or if both \tcode{lhs} and \tcode{rhs} do not have ownership of a stop state;

otherwise \tcode{false}.

\end{itemdescr}

\indexlibrarymember{swap}{stop_token}%

\begin{itemdecl}

friend void swap(stop_token& x, stop_token& y) noexcept;

\end{itemdecl}

\begin{itemdescr}

Equivalent to: \tcode{x.swap(y)}.

\end{itemdescr}

\rSec2[stopsource]{Class \tcode{stop_source}}%

\indexlibraryglobal{stop_source}%

\rSec3[stopsource.general]{General}

\indexlibraryglobal{stop_source}%

The class \tcode{stop_source} implements the semantics of making a stop request.

A stop request made on a \tcode{stop_source} object is visible to all

associated \tcode{stop_source} and \tcode{stop_token}\iref{stoptoken} objects.

Once a stop request has been made it cannot be withdrawn

(a subsequent stop request has no effect).

\indexlibraryglobal{nostopstate_t}%

\indexlibraryglobal{nostopstate}%

\begin{codeblock}

namespace std {

// no-shared-stop-state indicator

struct nostopstate_t {

explicit nostopstate_t() = default;

};

inline constexpr nostopstate_t nostopstate{};

class stop_source {

public:

// \ref{stopsource.cons}, constructors, copy, and assignment

stop_source();

explicit stop_source(nostopstate_t) noexcept;

stop_source(const stop_source&) noexcept;

stop_source(stop_source&&) noexcept;

stop_source& operator=(const stop_source&) noexcept;

stop_source& operator=(stop_source&&) noexcept;

~stop_source();

void swap(stop_source&) noexcept;

// \ref{stopsource.mem}, stop handling

[[nodiscard]] stop_token get_token() const noexcept;

[[nodiscard]] bool stop_possible() const noexcept;

[[nodiscard]] bool stop_requested() const noexcept;

bool request_stop() noexcept;

[[nodiscard]] friend bool

operator==(const stop_source& lhs, const stop_source& rhs) noexcept;

friend void swap(stop_source& lhs, stop_source& rhs) noexcept;

};

}

\end{codeblock}

\rSec3[stopsource.cons]{Constructors, copy, and assignment}

\indexlibraryctor{stop_source}%

\begin{itemdecl}

stop_source();

\end{itemdecl}

\begin{itemdescr}

Initialises \tcode{*this} to have ownership of a new stop state.

\tcode{stop_possible()} is \tcode{true}

and \tcode{stop_requested()} is \tcode{false}.

\tcode{bad_alloc} if memory cannot be allocated for the stop state.

\end{itemdescr}

\indexlibraryctor{stop_source}%

\begin{itemdecl}

explicit stop_source(nostopstate_t) noexcept;

\end{itemdecl}

\begin{itemdescr}

\tcode{stop_possible()} is \tcode{false} and

\tcode{stop_requested()} is \tcode{false}.

\begin{note}

No resources are allocated for the state.

\end{note}

\end{itemdescr}

\indexlibraryctor{stop_source}%

\begin{itemdecl}

stop_source(const stop_source& rhs) noexcept;

\end{itemdecl}

\begin{itemdescr}

\tcode{*this == rhs} is \tcode{true}.

\begin{note}

\tcode{*this} and \tcode{rhs} share the ownership of the same stop state,

if any.

\end{note}

\end{itemdescr}

\indexlibraryctor{stop_source}%

\begin{itemdecl}

stop_source(stop_source&& rhs) noexcept;

\end{itemdecl}

\begin{itemdescr}

\tcode{*this} contains the value of \tcode{rhs}

prior to the start of construction

and \tcode{rhs.stop_possible()} is \tcode{false}.

\end{itemdescr}

\indexlibrarydtor{stop_source}%

\begin{itemdecl}

~stop_source();

\end{itemdecl}

\begin{itemdescr}

Releases ownership of the stop state, if any.

\end{itemdescr}

\indexlibrarymember{operator=}{stop_source}%

\begin{itemdecl}

stop_source& operator=(const stop_source& rhs) noexcept;

\end{itemdecl}

\begin{itemdescr}

Equivalent to: \tcode{stop_source(rhs).swap(*this)}.

\tcode{*this}.

\end{itemdescr}

\indexlibrarymember{operator=}{stop_source}%

\begin{itemdecl}

stop_source& operator=(stop_source&& rhs) noexcept;

\end{itemdecl}

\begin{itemdescr}

Equivalent to: \tcode{stop_source(std::move(rhs)).swap(*this)}.

\tcode{*this}.

\end{itemdescr}

\indexlibrarymember{swap}{stop_source}%

\begin{itemdecl}

void swap(stop_source& rhs) noexcept;

\end{itemdecl}

\begin{itemdescr}

Exchanges the values of \tcode{*this} and \tcode{rhs}.

\end{itemdescr}

\rSec3[stopsource.mem]{Members}

\indexlibrarymember{get_token}{stop_source sc}%

\begin{itemdecl}

[[nodiscard]] stop_token get_token() const noexcept;

\end{itemdecl}

\begin{itemdescr}

\tcode{stop_token()} if \tcode{stop_possible()} is \tcode{false};

otherwise a new associated \tcode{stop_token} object.

\end{itemdescr}

\indexlibrarymember{stop_possible}{stop_source}%

\begin{itemdecl}

[[nodiscard]] bool stop_possible() const noexcept;

\end{itemdecl}

\begin{itemdescr}

\tcode{true} if \tcode{*this} has ownership of a stop state;

otherwise, \tcode{false}.

\end{itemdescr}

\indexlibrarymember{stop_requested}{stop_source}%

\begin{itemdecl}

[[nodiscard]] bool stop_requested() const noexcept;

\end{itemdecl}

\begin{itemdescr}

\tcode{true} if \tcode{*this} has ownership of a stop state

that has received a stop request;

otherwise, \tcode{false}.

\end{itemdescr}

\indexlibrarymember{request_stop}{stop_source}%

\begin{itemdecl}

bool request_stop() noexcept;

\end{itemdecl}

\begin{itemdescr}

If \tcode{*this} does not have ownership of a stop state, returns \tcode{false}.

Otherwise, atomically determines whether the owned stop state

has received a stop request,

and if not, makes a stop request.

The determination and making of the stop request are an

atomic read-modify-write operation\iref{intro.races}.

If the request was made,

the callbacks registered by associated \tcode{stop_callback} objects

are synchronously called.

If an invocation of a callback exits via an exception

then \tcode{terminate} is invoked\iref{except.terminate}.

\begin{note}

A stop request includes notifying all condition variables

of type \tcode{condition_variable_any}

temporarily registered during

an interruptible wait\iref{thread.condvarany.intwait}.

\end{note}

\tcode{stop_possible()} is \tcode{false}

or \tcode{stop_requested()} is \tcode{true}.

\tcode{true} if this call made a stop request;

otherwise \tcode{false}.

\end{itemdescr}

\rSec3[stopsource.nonmembers]{Non-member functions}

\indexlibrarymember{operator==}{stop_source}%

\begin{itemdecl}

[[nodiscard]] friend bool

operator==(const stop_source& lhs, const stop_source& rhs) noexcept;

\end{itemdecl}

\begin{itemdescr}

\tcode{true} if \tcode{lhs} and \tcode{rhs} have ownership

of the same stop state

or if both \tcode{lhs} and \tcode{rhs} do not have ownership of a stop state;

otherwise \tcode{false}.

\end{itemdescr}

\indexlibrarymember{swap}{stop_source}%

\begin{itemdecl}

friend void swap(stop_source& x, stop_source& y) noexcept;

\end{itemdecl}

\begin{itemdescr}

Equivalent to: \tcode{x.swap(y)}.

\end{itemdescr}

\rSec2[stopcallback]{Class template \tcode{stop_callback}}%

\indexlibraryglobal{stop_callback}%

\rSec3[stopcallback.general]{General}

\indexlibraryglobal{stop_callback}%

\begin{codeblock}

namespace std {

template<class Callback>

class stop_callback {

public:

using callback_type = Callback;

// \ref{stopcallback.cons}, constructors and destructor

template<class C>

explicit stop_callback(const stop_token& st, C&& cb)

noexcept(is_nothrow_constructible_v<Callback, C>);

template<class C>