void notify_one(); (since C++11) If any threads are waiting on *this, calling notify_one unblocks one of the waiting threads. Parameters (none). Return value (none). Exceptions noexcept specification: noexcept Notes The effects of notify_one()/notify_all() and wait()/wait_for()/wait_until() take place in a single total order, so it's impossible for notify_one() to, for example, be delayed and unblock a thread that started waiting just after the call to notify_one() was mad

template< class Lock, class Rep, class Period > std::cv_status wait_for( Lock& lock, const std::chrono::duration<Rep, Period>& rel_time); (1) (since C++11) template< class Lock, class Rep, class Period, class Predicate > bool wait_for( Lock& lock, const std::chrono::duration<Rep, Period>& rel_time, Predicate pred); (2) (since C++11) 1) Atomically releases lock, blocks the current execut

void notify_all(); (since C++11) Unblocks all threads currently waiting for *this. Parameters (none). Return value (none). Exceptions noexcept specification: noexcept Notes The effects of notify_one()/notify_all() and wait()/wait_for()/wait_until() take place in a single total order, so it's impossible for notify_one() to, for example, be delayed and unblock a thread that started waiting just after the call to notify_one() was made. The notifying thread does not need to ho

template< class Lock > void wait( Lock& lock ); (1) (since C++11) template< class Lock, class Predicate > void wait( Lock& lock, Predicate pred ); (2) (since C++11) wait causes the current thread to block until the condition variable is notified or a spurious wakeup occurs, optionally looping until some predicate is satisfied. 1) Atomically releases lock, blocks the current executing thread, and adds it to the list of threads waiting on *this. The thread will

void wait( std::unique_lock<std::mutex>& lock ); (1) (since C++11) template< class Predicate > void wait( std::unique_lock<std::mutex>& lock, Predicate pred ); (2) (since C++11) wait causes the current thread to block until the condition variable is notified or a spurious wakeup occurs, optionally looping until some predicate is satisfied. 1) Atomically releases lock, blocks the current executing thread, and adds it to the list of threads waiting on *thi

template< class Clock, class Duration > std::cv_status wait_until( std::unique_lock<std::mutex>& lock, const std::chrono::time_point<Clock, Duration>& timeout_time ); (1) (since C++11) template< class Clock, class Duration, class Predicate > bool wait_until( std::unique_lock<std::mutex>& lock, const std::chrono::time_point<Clock, Duration>& timeout_time, Predicate pred ); (2

condition_variable_any(); (1) (since C++11) condition_variable_any(const condition_variable_any&) = delete; (2) (since C++11) 1) Constructs an object of type std::condition_variable_any. 2) Copy constructor is deleted. Parameters (none). Exceptions 1) May throw std::system_error with std::error_condition equal to std::errc::operation_not_permitted if the thread has no privilege to create a condition variable, std::errc::resource_unavailable_try_again if a non-memory reso

template< class Rep, class Period > std::cv_status wait_for( std::unique_lock<std::mutex>& lock, const std::chrono::duration<Rep, Period>& rel_time); (1) (since C++11) template< class Rep, class Period, class Predicate > bool wait_for( std::unique_lock<std::mutex>& lock, const std::chrono::duration<Rep, Period>& rel_time, Predicate pred); (2) (since C++11) 1) Atomically rele

Defined in header <condition_variable> class condition_variable_any; (since C++11) The condition_variable_any class is a generalization of std::condition_variable. Whereas std::condition_variable works only on std::unique_lock<std::mutex>, condition_variable_any can operate on any user-defined lock that meets the BasicLockable requirements. See std::condition_variable for the description of the semantics of condition variables. The class std::condition_variable_any is

Defined in header <condition_variable> class condition_variable; (since C++11) The condition_variable class is a synchronization primitive that can be used to block a thread, or multiple threads at the same time, until another thread both modifies a shared variable (the condition), and notifies the condition_variable. The thread that intends to modify the variable has to. acquire a std::mutex (typically via std::lock_guard) perform the modification while the lock is held