[thread.thread.class]

An object of type thread::id provides a unique identifier for each thread of execution and a single distinct value for all thread objects that do not represent a thread of execution ([thread.thread.class]).

Each thread of execution has an associated thread::id object that is not equal to the thread::id object of any other thread of execution and that is not equal to the thread::id object of any thread object that does not represent threads of execution.

The text representation for the character type charT of an object of type thread::id is an unspecified sequence of charT such that, for two objects of type thread::id x and y, if x == y is true, the thread::id objects have the same text representation, and if x != y is true, the thread::id objects have distinct text representations.

[Note 1:

Relational operators allow thread::id objects to be used as keys in associative containers.

— end note]

🔗

id() noexcept;

Postconditions: The constructed object does not represent a thread of execution.

🔗

bool operator=(thread::id x, thread::id y) noexcept;

Returns: true only if x and y represent the same thread of execution or neither x nor y represents a thread of execution.

🔗

strong_ordering operator<=>(thread::id x, thread::id y) noexcept;

Let P(x, y) be an unspecified total ordering over thread::id as described in [alg.sorting].

Returns: strong_ordering::less if P(x, y) is true.

Otherwise, strong_ordering::greater if P(y, x) is true.

Otherwise, strong_ordering::equal.

🔗

template<class charT, class traits>
  basic_ostream<charT, traits>&
    operator<(basic_ostream<charT, traits>& out, thread::id id);

Effects: Inserts the text representation for charT of id into out.

Returns: out.

🔗

template<class charT> struct formatter<thread::id, charT>;

formatter<thread::id, charT> interprets format-spec as a thread-id-format-spec.

The syntax of format specifications is as follows:

thread-id-format-spec :
fill-and-align

{o p t width {o p t}_{o p t}}_{o p t width {o p t}_{o p t}}

[Note 2:

The productions fill-and-align and width are described in [format.string.std].

— end note]

A thread::id object is formatted by writing its text representation for charT to the output with additional padding and adjustments as specified by the format specifiers.

🔗

template<> struct hash<thread::id>;

The specialization is enabled ([unord.hash]).

32.4.3.3 Constructors [thread.thread.constr]

🔗

thread() noexcept;

Postconditions: get_id() == id().

🔗

template<class F, class. Args> explicit thread(F&& f, Args&&. args);

Mandates: The following are all true:

(4.1)
is_constructible_v<decay_t<F>, F>,
(4.2)
(is_constructible_v<decay_t<Args>, Args> && ..), and
(4.3)
is_invocable_v<decay_t<F>, decay_t<Args>.>.

Effects: The new thread of execution executes invoke(auto(std::forward<F>(f)), / for invoke, see [func.invoke] auto(std::forward<Args>(args)).) with the values produced by auto being materialized ([conv.rval]) in the constructing thread.

Any return value from this invocation is ignored.

[Note 1:

This implies that any exceptions not thrown from the invocation of the copy of f will be thrown in the constructing thread, not the new thread.

— end note]

If the invocation of invoke terminates with an uncaught exception, terminate is invoked ([except.terminate]).

Synchronization: The completion of the invocation of the constructor synchronizes with the beginning of the invocation of the copy of f.

Error conditions:

(9.1)
resource_unavailable_try_again — the system lacked the necessary resources to create another thread, or the system-imposed limit on the number of threads in a process would be exceeded.

🔗

thread(thread&& x) noexcept;

Postconditions: x.get_id() == id() and get_id() returns the value of x.get_id() prior to the start of construction.

32.4.3.4 Destructor [thread.thread.destr]

🔗

~thread();

Effects: If joinable(), invokes terminate ([except.terminate]).

Otherwise, has no effects.

[Note 1:

Either implicitly detaching or joining a joinable() thread in its destructor can result in difficult to debug correctness (for detach) or performance (for join) bugs encountered only when an exception is thrown.

These bugs can be avoided by ensuring that the destructor is never executed while the thread is still joinable.

— end note]

32.4.3.5 Assignment [thread.thread.assign]

🔗

thread& operator=(thread&& x) noexcept;

Effects: If joinable(), invokes terminate ([except.terminate]).

Otherwise, assigns the state of x to *this and sets x to a default constructed state.

Postconditions: x.get_id() == id() and get_id() returns the value of x.get_id() prior to the assignment.

Returns: *this.

32.4.3.6 Members [thread.thread.member]

🔗

void swap(thread& x) noexcept;

Effects: Swaps the state of *this and x.

🔗

bool joinable() const noexcept;

Returns: get_id() != id().

🔗

void join();

Synchronization: The completion of the thread represented by *this synchronizes with ([intro.multithread]) the corresponding successful join() return.

[Note 1:

Operations on *this are not synchronized.

— end note]

Throws: system_error when an exception is required ([thread.req.exception]).

Error conditions:

(7.1)
resource_deadlock_would_occur — if deadlock is detected or get_id() == this_thread::get_id().
(7.2)
no_such_process — if the thread is not valid.
(7.3)
invalid_argument — if the thread is not joinable.

🔗

void detach();

Effects: The thread represented by *this continues execution without the calling thread blocking.

When detach() returns, *this no longer represents the possibly continuing thread of execution.

When the thread previously represented by *this ends execution, the implementation releases any owned resources.

Throws: system_error when an exception is required ([thread.req.exception]).

Error conditions:

(11.1)
no_such_process — if the thread is not valid.
(11.2)
invalid_argument — if the thread is not joinable.

🔗

id get_id() const noexcept;

Returns: A default constructed id object if *this does not represent a thread, otherwise this_thread::get_id() for the thread of execution represented by *this.

32.4.3.7 Static members [thread.thread.static]

🔗

unsigned hardware_concurrency() noexcept;

Returns: The number of hardware thread contexts.

[Note 1:

This value should only be considered to be a hint.

— end note]

If this value is not computable or well-defined, an implementation should return 0.

32.4.3.8 Specialized algorithms [thread.thread.algorithm]

🔗

void swap(thread& x, thread& y) noexcept;

Effects: As if by x.swap(y).

32.4.3.2 Class thread​::​id [thread.thread.id]

32.4.3.3 Constructors [thread.thread.constr]

32.4.3.4 Destructor [thread.thread.destr]

32.4.3.5 Assignment [thread.thread.assign]

32.4.3.6 Members [thread.thread.member]

32.4.3.7 Static members [thread.thread.static]

32.4.3.8 Specialized algorithms [thread.thread.algorithm]

32.4.3.2 Class thread::id [thread.thread.id]