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 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; // See [thread.req.native]
native_handle_type native_handle(); // See [thread.req.native]
};
}
The class condition_variable shall be a standard-layout class (Clause [class]).
Effects: Constructs an object of type condition_variable.
Throws: system_error when an exception is required ([thread.req.exception]).
Error conditions:
resource_unavailable_try_again — if some non-memory resource limitation prevents initialization.
Requires: There shall be no thread blocked on *this. [ Note: That is, all threads shall have been notified; they may subsequently block on the lock specified in the wait. This relaxes the usual rules, which would have required all wait calls to happen before destruction. Only the notification to unblock the wait must happen before destruction. The user must take care to ensure that no threads wait on *this once the destructor has been started, especially when the waiting threads are calling the wait functions in a loop or using the overloads of wait, wait_for, or wait_until that take a predicate. — end note ]
Effects: Destroys the object.
Effects: If any threads are blocked waiting for *this, unblocks one of those threads.
Effects: Unblocks all threads that are blocked waiting for *this.
void wait(unique_lock<mutex>& lock);
Requires: lock.owns_lock() is true and lock.mutex() is locked by the calling thread, and either
no other thread is waiting on this condition_variable object or
lock.mutex() returns the same value for each of the lock arguments supplied by all concurrently waiting (via wait, wait_for, or wait_until) threads.
Remarks: If the function fails to meet the postcondition, std::terminate() shall be called ([except.terminate]). [ Note: This can happen if the re-locking of the mutex throws an exception. — end note ]
Postcondition: lock.owns_lock() is true and lock.mutex() is locked by the calling thread.
Throws: Nothing.
template <class Predicate>
void wait(unique_lock<mutex>& lock, Predicate pred);
Requires: lock.owns_lock() is true and lock.mutex() is locked by the calling thread, and either
no other thread is waiting on this condition_variable object or
lock.mutex() returns the same value for each of the lock arguments supplied by all concurrently waiting (via wait, wait_for, or wait_until) threads.
Effects: Equivalent to:
while (!pred()) wait(lock);
Remarks: If the function fails to meet the postcondition, std::terminate() shall be called ([except.terminate]). [ Note: This can happen if the re-locking of the mutex throws an exception. — end note ]
Postcondition: lock.owns_lock() is true and lock.mutex() is locked by the calling thread.
Throws: Timeout-related exceptions ([thread.req.timing]) or any exception thrown by pred.
template <class Clock, class Duration>
cv_status wait_until(unique_lock<mutex>& lock,
const chrono::time_point<Clock, Duration>& abs_time);
Requires: lock.owns_lock() is true and lock.mutex() is locked by the calling thread, and either
no other thread is waiting on this condition_variable object or
lock.mutex() returns the same value for each of the lock arguments supplied by all concurrently waiting (via wait, wait_for, or wait_until) threads.
Effects:
Atomically calls lock.unlock() and blocks on *this.
When unblocked, calls lock.lock() (possibly blocking on the lock), then returns.
The function will unblock when signaled by a call to notify_one(), a call to notify_all(), expiration of the absolute timeout ([thread.req.timing]) specified by abs_time, or spuriously.
If the function exits via an exception, lock.lock() shall be called prior to exiting the function.
Remarks: If the function fails to meet the postcondition, std::terminate() shall be called ([except.terminate]). [ Note: This can happen if the re-locking of the mutex throws an exception. — end note ]
Postcondition: lock.owns_lock() is true and lock.mutex() is locked by the calling thread.
Returns: cv_status::timeout if the absolute timeout ([thread.req.timing]) specified by abs_time expired, otherwise cv_status::no_timeout.
Throws: Timeout-related exceptions ([thread.req.timing]).
template <class Rep, class Period>
cv_status wait_for(unique_lock<mutex>& lock,
const chrono::duration<Rep, Period>& rel_time);
Requires: lock.owns_lock() is true and lock.mutex() is locked by the calling thread, and either
no other thread is waiting on this condition_variable object or
lock.mutex() returns the same value for each of the lock arguments supplied by all concurrently waiting (via wait, wait_for, or wait_until) threads.
Effects: Equivalent to:
return wait_until(lock, chrono::steady_clock::now() + rel_time);
Returns: cv_status::timeout if the relative timeout ([thread.req.timing]) specified by rel_time expired, otherwise cv_status::no_timeout.
Remarks: If the function fails to meet the postcondition, std::terminate() shall be called ([except.terminate]). [ Note: This can happen if the re-locking of the mutex throws an exception. — end note ]
Postcondition: lock.owns_lock() is true and lock.mutex() is locked by the calling thread.
Throws: Timeout-related exceptions ([thread.req.timing]).
template <class Clock, class Duration, class Predicate>
bool wait_until(unique_lock<mutex>& lock,
const chrono::time_point<Clock, Duration>& abs_time,
Predicate pred);
Requires: lock.owns_lock() is true and lock.mutex() is locked by the calling thread, and either
no other thread is waiting on this condition_variable object or
lock.mutex() returns the same value for each of the lock arguments supplied by all concurrently waiting (via wait, wait_for, or wait_until) threads.
Effects: Equivalent to:
while (!pred())
if (wait_until(lock, abs_time) == cv_status::timeout)
return pred();
return true;
Remarks: If the function fails to meet the postcondition, std::terminate() shall be called ([except.terminate]). [ Note: This can happen if the re-locking of the mutex throws an exception. — end note ]
Postcondition: lock.owns_lock() is true and lock.mutex() is locked by the calling thread.
[ Note: The returned value indicates whether the predicate evaluated to true regardless of whether the timeout was triggered. — end note ]
Throws: Timeout-related exceptions ([thread.req.timing]) or any exception thrown by pred.
template <class Rep, class Period, class Predicate>
bool wait_for(unique_lock<mutex>& lock,
const chrono::duration<Rep, Period>& rel_time,
Predicate pred);
Requires: lock.owns_lock() is true and lock.mutex() is locked by the calling thread, and either
no other thread is waiting on this condition_variable object or
lock.mutex() returns the same value for each of the lock arguments supplied by all concurrently waiting (via wait, wait_for, or wait_until) threads.
Effects: Equivalent to:
return wait_until(lock, chrono::steady_clock::now() + rel_time, std::move(pred));
[ Note: There is no blocking if pred() is initially true, even if the timeout has already expired. — end note ]
Remarks: If the function fails to meet the postcondition, std::terminate() shall be called ([except.terminate]). [ Note: This can happen if the re-locking of the mutex throws an exception. — end note ]
Postcondition: lock.owns_lock() is true and lock.mutex() is locked by the calling thread.
[ Note: The returned value indicates whether the predicate evaluates to true regardless of whether the timeout was triggered. — end note ]
Throws: Timeout-related exceptions ([thread.req.timing]) or any exception thrown by pred.