# 标准库头文件 <condition_variable>

< cpp‎ | header

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

### 类
condition_variable (C++11) | 提供与 std::unique_lock 关联的条件变量 (类)
condition_variable_any (C++11) | 提供与任何锁类型关联的条件变量 (类)
cv_status (C++11) | 列出条件变量上定时等待的可能结果 (枚举)
### 函数
notify_all_at_thread_exit (C++11) | 安排到在此线程完全结束时对 `notify_all` 的调用 (函数)

### 概要

    namespace std {
      class condition_variable;
      class condition_variable_any;

      void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);

      enum class cv_status { no_timeout, timeout };
    }

#### 类 std::condition_variable

    namespace std {
      class condition_variable {
      public:
        condition_variable();
        ~condition_variable();

        condition_variable(const condition_variable&) = delete;
        condition_variable& operator=(const condition_variable&) = delete;

        void notify_one() noexcept;
        void notify_all() noexcept;
        void wait(unique_lock<mutex>& lock);
        template<class Pred>
          void wait(unique_lock<mutex>& lock, Pred pred);
        template<class Clock, class Duration>
          cv_status wait_until(unique_lock<mutex>& lock,
                               const chrono::time_point<Clock, Duration>& abs_time);
        template<class Clock, class Duration, class Pred>
          bool wait_until(unique_lock<mutex>& lock,
                          const chrono::time_point<Clock, Duration>& abs_time, Pred pred);
        template<class Rep, class Period>
          cv_status wait_for(unique_lock<mutex>& lock,
                             const chrono::duration<Rep, Period>& rel_time);
        template<class Rep, class Period, class Pred>
          bool wait_for(unique_lock<mutex>& lock,
                        const chrono::duration<Rep, Period>& rel_time, Pred pred);

        using native_handle_type = /* 由实现定义 */;
        native_handle_type native_handle();
      };
    }

#### 类 std::condition_variable_any

    namespace std {
      class condition_variable_any {
      public:
        condition_variable_any();
        ~condition_variable_any();

        condition_variable_any(const condition_variable_any&) = delete;
        condition_variable_any& operator=(const condition_variable_any&) = delete;

        void notify_one() noexcept;
        void notify_all() noexcept;

        // 不可中断等待
        template<class Lock>
          void wait(Lock& lock);
        template<class Lock, class Pred>
          void wait(Lock& lock, Pred pred);

        template<class Lock, class Clock, class Duration>
          cv_status wait_until(Lock& lock,
                               const chrono::time_point<Clock, Duration>& abs_time);
        template<class Lock, class Clock, class Duration, class Pred>
          bool wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& abs_time,
                          Pred pred);
        template<class Lock, class Rep, class Period>
          cv_status wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
        template<class Lock, class Rep, class Period, class Pred>
          bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Pred pred);

        // 可中断等待
        template<class Lock, class Pred>
          bool wait(Lock& lock, stop_token stoken, Pred pred);
        template<class Lock, class Clock, class Duration, class Pred>
          bool wait_until(Lock& lock, stop_token stoken,
                          const chrono::time_point<Clock, Duration>& abs_time, Pred pred);
        template<class Lock, class Rep, class Period, class Pred>
          bool wait_for(Lock& lock, stop_token stoken,
                        const chrono::duration<Rep, Period>& rel_time, Pred pred);
      };
    }