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 be unblocked when notify_all()
or notify_one()
is executed. It may also be unblocked spuriously. When unblocked, regardless of the reason, lock
is reacquired and wait
exits. If this function exits via exception, lock
is also reacquired. (until C++14) 2) Equivalent to This overload may be used to ignore spurious awakenings while waiting for a specific condition to become true. Note that before enter to this method
while (!pred()) { wait(lock); }
lock
must be acquired, after wait(lock)
exits it is also reacquired, i.e. lock
can be used as a guard to pred()
access.If these functions fail to meet the postconditions (lock is locked by the calling thread), std::terminate is called. For example, this could happen if relocking the mutex throws an exception, | (since C++14) |
Parameters
lock | - | an object of type Lock that meets the BasicLockable requirements, which must be locked by the current thread |
pred | - | predicate which returns false if the waiting should be continued. The signature of the predicate function should be equivalent to the following:
|
Return value
(none).
Exceptions
May throw | (until C++14) |
Does not throw. | (since C++14) |
Example
#include <iostream> #include <condition_variable> #include <thread> #include <chrono> std::condition_variable_any cv; std::mutex cv_m; // This mutex is used for three purposes: // 1) to synchronize accesses to i // 2) to synchronize accesses to std::cerr // 3) for the condition variable cv int i = 0; void waits() { std::unique_lock<std::mutex> lk(cv_m); std::cerr << "Waiting... \n"; cv.wait(lk, []{return i == 1;}); std::cerr << "...finished waiting. i == 1\n"; } void signals() { std::this_thread::sleep_for(std::chrono::seconds(1)); { std::lock_guard<std::mutex> lk(cv_m); std::cerr << "Notifying...\n"; } cv.notify_all(); std::this_thread::sleep_for(std::chrono::seconds(1)); { std::lock_guard<std::mutex> lk(cv_m); i = 1; std::cerr << "Notifying again...\n"; } cv.notify_all(); } int main() { std::thread t1(waits), t2(waits), t3(waits), t4(signals); t1.join(); t2.join(); t3.join(); t4.join(); }
Possible output:
Waiting... Waiting... Waiting... Notifying... Notifying again... ...finished waiting. i == 1 ...finished waiting. i == 1 ...finished waiting. i == 1
See also
blocks the current thread until the condition variable is woken up or after the specified timeout duration (public member function) | |
blocks the current thread until the condition variable is woken up or until specified time point has been reached (public member function) |
Please login to continue.