Standard library header <thread>

 

C++

Language

Standard Library Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library(C++20)

Diagnostics library

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)

Atomic operations library(C++11)

Thread support library(C++11)

Technical Specifications

 

Standard Library headers

Language Support
<cstddef> <cstdlib> <version> <limits> <climits>	<cfloat> <cstdint> <new> <typeinfo>	<source_location> <exception> <initializer_list> <compare>	<coroutine> <csignal> <csetjmp> <cstdarg>
Concepts
<concepts>
Diagnostics
<stdexcept>	<cassert>	<cerrno>	<system_error>
General utilities
<utility> <memory> <memory_resource> <scoped_allocator>	<bitset> <tuple> <optional> <any>	<variant> <type_traits> <ratio> <chrono>	<typeindex> <functional> <ctime>
Strings
<string> <string_view> <cstring>	<charconv> <format>	<cctype> <cwctype>	<cwchar> <cuchar>
Localization
<locale>	<codecvt>	<clocale>
Containers
<span> <array> <vector>	<deque> <forward_list> <list>	<map> <set> <queue>	<unordered_map> <unordered_set> <stack>
Iterators
<iterator>
Ranges
<ranges>
Algorithms
<algorithm>	<execution>
Numerics
<complex> <random>	<valarray> <numeric>	<bit> <numbers>	<cfenv> <cmath>
Input/Output
<iosfwd> <ios> <iomanip> <streambuf>	<istream> <ostream> <iostream>	<sstream> <fstream> <syncstream>	<cstdio> <cinttypes> <strstream>
Regular expressions
<regex>
Filesystem support
<filesystem>
Thread support
<thread> <atomic> <mutex>	<shared_mutex> <condition_variable> <future>	<stop_token> <semaphore>	<latch> <barrier>
C compatibility
<ciso646> <cstdalign>	<cstdbool> <ccomplex>	<ctgmath>

 

This header is part of the thread support library.

Includes
<compare> (C++20)	Three-way comparison operator support
Namespaces
this_thread	provide functions that access the current thread of execution
Classes
thread (C++11)	manages a separate thread (class)
jthread (C++20)	std::thread with support for auto-joining and cancellation (class)
std::hash<std::thread::id>	specializes std::hash (class template specialization)
Functions
std::swap(std::thread) (C++11)	specializes the std::swap algorithm (function)
operator==operator!=operator< operator<= operator> operator>= operator<=> (removed in C++20)(removed in C++20)(removed in C++20)(removed in C++20)(removed in C++20)(C++20)	compares two thread::id objects (function)
operator<<	serializes a thread::id object (function template)
Defined in namespace std::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)

Synopsis

#include <compare>   namespace std {class thread;   void swap(thread& x, thread& y)noexcept;   // class jthreadclass jthread;   namespace this_thread { thread::id get_id()noexcept;   void yield()noexcept;template<class Clock, class Duration>void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);template<class Rep, class Period>void sleep_for(const chrono::duration<Rep, Period>& rel_time);}}

Class std::thread

namespace std {class thread {public:// typesclass id;using native_handle_type =/* implementation-defined */;   // construct/copy/destroy thread()noexcept;template<class F, class... Args>explicit thread(F&& f, Args&&... args); ~thread(); thread(const thread&)= delete; thread(thread&&)noexcept; thread& operator=(const thread&)= delete; thread& operator=(thread&&)noexcept;   // membersvoid swap(thread&)noexcept;bool joinable()constnoexcept;void join();void detach(); id get_id()constnoexcept; native_handle_type native_handle();   // static membersstaticunsignedint hardware_concurrency()noexcept;};}

Class std::jthread

namespace std {class jthread {public:// typesusing id = thread::id;using native_handle_type = thread::native_handle_type;   // constructors, move, and assignment jthread()noexcept;template<class F, class... Args>explicit jthread(F&& f, Args&&... args); ~jthread(); jthread(const jthread&)= delete; jthread(jthread&&)noexcept; jthread& operator=(const jthread&)= delete; jthread& operator=(jthread&&)noexcept;   // membersvoid swap(jthread&)noexcept;[[nodiscard]]bool joinable()constnoexcept;void join();void detach();[[nodiscard]] id get_id()constnoexcept;[[nodiscard]] native_handle_type native_handle();   // stop token handling[[nodiscard]] stop_source get_stop_source()noexcept;[[nodiscard]] stop_token get_stop_token()constnoexcept;bool request_stop()noexcept;   // specialized algorithmsfriendvoid swap(jthread& lhs, jthread& rhs)noexcept;   // static members[[nodiscard]]staticunsignedint hardware_concurrency()noexcept;   private: stop_source ssource;// exposition only};}

Class std::thread::id

namespace std {class thread::id{public: id()noexcept;};   bool operator==(thread::id x, thread::id y)noexcept; strong_ordering operator<=>(thread::id x, thread::id y)noexcept;   template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& out, thread::id id);   // hash supporttemplate<class T>struct hash;template<>struct hash<thread::id>;}