标准库标头 <thread>

来自cppreference.com
See More


 
C++
 
标准库头
通用工具
<any> (C++17)
<bitset>
<bit> (C++20)
<charconv> (C++17)
<expected> (C++23)
<format> (C++20)
<functional>
<optional> (C++17)
<stdbit.h> (C++26)
<tuple> (C++11)
<typeindex> (C++11)
<utility>
<variant> (C++17)
容器
<array> (C++11)
<deque>
<flat_map> (C++23)
<flat_set> (C++23)
<forward_list> (C++11)
<hive> (C++26)
<inplace_vector> (C++26)   
<list>
<map>
<mdspan> (C++23)
<queue>
<set>
<span> (C++20)
<stack>
<unordered_map> (C++11)
<unordered_set> (C++11)
<vector>
迭代器
<iterator>
范围
<generator> (C++23)
<ranges> (C++20)
 

此头文件是线程支持库的一部分。

包含

(C++20)
 三路比较运算符支持[编辑]

命名空间

this_thread 提供访问当前执行线程的函数

类

(C++11)
 管理单独的线程
(类) [编辑]
(C++20)
 支持自动合并和取消的 std::thread
(类) [编辑]
特化 std::hash
(类模板特化)

函数

(C++11)
 特化 std::swap 算法
(函数) [编辑]
(C++20 移除)(C++20 移除)(C++20 移除)(C++20 移除)(C++20 移除)(C++20)
 比较两个 thread::id 对象
(函数) [编辑]
序列化 thread::id 对象
(函数模板) [编辑]
在命名空间 std::this_thread 定义
(C++11)
 建议实现重新调度各执行线程
(函数) [编辑]
(C++11)
 返回当前线程的线程 id
(函数) [编辑]
(C++11)
 使当前线程的执行停止指定的时间段
(函数) [编辑]
(C++11)
 使当前线程的执行停止直到指定的时间点
(函数) [编辑]

概要

#include <compare>

namespace std {
  // 类 thread
  class thread;

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

  // 类 jthread
  class jthread;

  // 命名空间 this_thread
  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);
  }
}

类 std::thread

namespace std {
  class thread
  {
  public:
    // 类 thread::id
    class id;
    using native_handle_type = /* 由实现定义 */;

    // 构造/复制/销毁
    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;

    // 成员
    void swap(thread&) noexcept;
    bool joinable() const noexcept;
    void join();
    void detach();
    id get_id() const noexcept;
    native_handle_type native_handle();

    // 静态成员
    static unsigned int hardware_concurrency() noexcept;
  };
}

类 std::jthread

namespace std {
  class jthread
  {
  public:
    // 类型
    using id                 = thread::id;
    using native_handle_type = thread::native_handle_type;

    // 构造函数、移动与赋值
    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;

    // 成员
    void swap(jthread&) noexcept;
    bool joinable() const noexcept;
    void join();
    void detach();
    id get_id() const noexcept;
    native_handle_type native_handle();

    // 停止记号处理
    stop_source get_stop_source() noexcept;
    stop_token get_stop_token() const noexcept;
    bool request_stop() noexcept;

    // 特化的算法
    friend void swap(jthread& lhs, jthread& rhs) noexcept;

    // 静态成员
    static unsigned int hardware_concurrency() noexcept;

  private:
    stop_source ssource; // 仅用于阐释
  };
}

类 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);

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

  // 散列支持
  template<class T>
  struct hash;
  template<>
  struct hash<thread::id>;
}