# Standard library header <condition_variable>

From cppreference.com
< cpp‎ | header

This header is part of the thread support library.

### Classes

condition_variable (C++11) | provides a condition variable associated with a std::unique_lock (class)
condition_variable_any (C++11) | provides a condition variable associated with any lock type (class)
cv_status (C++11) | lists the possible results of timed waits on condition variables (enum)

### Functions

notify_all_at_thread_exit (C++11) | schedules a call to `notify_all` to be invoked when this thread is completely finished (function)

### Synopsis

    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
        };
    }

#### Class std::condition_variable

    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 Predicate>
            void wait(unique_lock<mutex>& lock, Predicate 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 Predicate>
            bool wait_until(unique_lock<mutex>& lock,
                            const chrono::time_point<Clock, Duration>& abs_time,
                            Predicate 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 Predicate>
            bool wait_for(unique_lock<mutex>& lock,
                          const chrono::duration<Rep, Period>& rel_time,
                          Predicate pred);

        typedef implementation-defined native_handle_type;
        native_handle_type native_handle();
    };

#### Class std::condition_variable_any

    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 Predicate>
            void wait(Lock& lock, Predicate 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 Predicate>
            bool wait_until(Lock& lock,
                            const chrono::time_point<Clock, Duration>& abs_time,
                            Predicate 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 Predicate>
            bool wait_for(Lock& lock,
                          const chrono::duration<Rep, Period>& rel_time,
                          Predicate pred);
    };

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/header/condition_variable&oldid=105132"