# 标准库头文件 <thread>

< cpp‎ | header

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

### 包含
<compare> (C++20) | 三路比较运算符支持
### 命名空间
`this_thread` | 提供访问当前执行线程的函数
### 类
thread (C++11) | 管理单独的线程 (类)
jthread (C++20) | 有自动合并和取消支持的 std::thread (类)
std::hash<std::thread::id> | 特化 std::hash (类模板特化)
### 函数
std::swap(std::thread) (C++11) | 特化 std::swap 算法 (函数)
operator==operator!=operator< operator<= operator> operator>= operator<=> (C++20 中移除)(C++20 中移除)(C++20 中移除)(C++20 中移除)(C++20 中移除)(C++20) | 比较两个 `thread::id` 对象 (函数)
operator<< | 序列化 `thread::id` 对象 (函数模板)
定义于命名空间 `std::this_thread`
yield (C++11) | 建议实现重新调度各执行线程 (函数)
get_id (C++11) | 返回当前线程的线程 id (函数)
sleep_for (C++11) | 使当前线程的执行停止指定的时间段 (函数)
sleep_until (C++11) | 使当前线程的执行停止直到指定的时间点 (函数)

### 概要

    #include <compare>

    namespace std {
      class thread;

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

      // 类 jthread
      class 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);
      }
    }

#### 类 std::thread

    namespace std {
      class thread {
      public:
        // 类型
        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;
        [[nodiscard]] bool joinable() const noexcept;
        void join();
        void detach();
        [[nodiscard]] id get_id() const noexcept;
        [[nodiscard]] native_handle_type native_handle();

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

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

        // 静态成员
        [[nodiscard]] 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 T> struct hash;
      template<> struct hash<thread::id>;
    }