template< class Lock, class Clock, class Duration > std::cv_status wait_until( Lock& lock, const std::chrono::time_point<Clock, Duration>& timeout_time ); | (1) | (since C++11) |
template< class Lock, class Clock, class Duration, class Predicate > bool wait_until( Lock& lock, const std::chrono::time_point<Clock, Duration>& timeout_time, Predicate pred ); | (2) | (since C++11) |
wait_until
causes the current thread to block until the condition variable is notified, a specific time is reached, or a spurious wakeup occurs, optionally looping until some predicate is satisfied.
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, or when the absolute time point timeout_time
is reached. It may also be unblocked spuriously. When unblocked, regardless of the reason, lock
is reacquired and wait_until
exits. If this function exits via exception, lock
is also reacquired. (until C++14) while (!pred()) { if (wait_until(lock, abs_time) == std::cv_status::timeout) { return pred(); } } return true;
If these functions fail to meet the postcondition (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 requirements of BasicLockable , which must be locked by the current thread |
timeout_time | - | an object of type std::chrono::time_point representing the time when to stop waiting |
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
std::cv_status::timeout
if the absolute timeout specified by abs_time
was reached, std::cv_status::no_timeout
overwise.false
if the predicate pred
still evaluates to false
after the abs_time
timeout expired, otherwise true
. If the timeout had already expired, evaluates and returns the result of pred
.Exceptions
May throw | (until C++14) |
Any exception thrown by clock, time point, or duration during the execution (clocks, time points, and durations provided by the standard library never throw). | (since C++14) |
Notes
The clock tied to timeout_time
is used, which is not required to be a monotonic clock.There are no guarantees regarding the behavior of this function if the clock is adjusted discontinuously, but the existing implementations convert timeout_time
from Clock
to std::chrono::system_clock
and delegate to POSIX pthread_cond_timedwait so that the wait honors ajustments to the system clock, but not to the the user-provided Clock
. In any case, the function also may wait for longer than until after timeout_time
has been reached due to scheduling or resource contention delays.
Even if the clock in use is std::chrono::steady_clock
or another monotonic clock, a system clock adjustment may induce a spurious wakeup.
Example
#include <iostream> #include <atomic> #include <condition_variable> #include <thread> #include <chrono> using namespace std::literals; std::condition_variable cv; std::mutex cv_m; std::atomic<int> i{0}; void waits(int idx) { std::unique_lock<std::mutex> lk(cv_m); auto now = std::chrono::system_clock::now(); if(cv.wait_until(lk, now + idx*100ms, [](){return i == 1;})) std::cerr << "Thread " << idx << " finished waiting. i == " << i << '\n'; else std::cerr << "Thread " << idx << " timed out. i == " << i << '\n'; } void signals() { std::this_thread::sleep_for(120ms); std::cerr << "Notifying...\n"; cv.notify_all(); std::this_thread::sleep_for(100ms); i = 1; std::cerr << "Notifying again...\n"; cv.notify_all(); } int main() { std::thread t1(waits, 1), t2(waits, 2), t3(waits, 3), t4(signals); t1.join(); t2.join(); t3.join(); t4.join(); }
Possible output:
Thread 1 timed out. i == 0 Notifying... Thread 2 timed out. i == 0 Notifying again... Thread 3 finished waiting. i == 1
See also
blocks the current thread until the condition variable is woken up (public member function) | |
blocks the current thread until the condition variable is woken up or after the specified timeout duration (public member function) |
Please login to continue.