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 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 relative timeout rel_time expires. It may also be unblocked spuriously. When unblocked, regardless of the reason, lock is reacquired and wait_for() exits. If this function exits via exception, lock is also reacquired. (until C++14) 2) Equivalent to
return wait_until(lock, std::chrono::steady_clock::now() + rel_time, std::move(pred). This overload may be used to ignore spurious awakenings.A steady clock is used to measure the duration. This function may block for longer than timeout_duration due to scheduling or resource contention delays.
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 BasicLockable requirements, which must be locked by the current thread |
| rel_time | - | an object of type std::chrono::duration representing the maximum time to spend 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
1)
std::cv_status::timeout if the relative timeout specified by rel_time expired, std::cv_status::no_timeout otherwise. 2)
false if the predicate pred still evaluates to false after the rel_time timeout expired, otherwise true.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) |
Example
#include <iostream>
#include <atomic>
#include <condition_variable>
#include <thread>
#include <chrono>
std::condition_variable_any cv;
std::mutex cv_m;
std::atomic<int> i{0};
void waits(int idx)
{
std::unique_lock<std::mutex> lk(cv_m);
if(cv.wait_for(lk, std::chrono::milliseconds(idx*100), [](){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(std::chrono::milliseconds(120));
std::cerr << "Notifying...\n";
cv.notify_all();
std::this_thread::sleep_for(std::chrono::milliseconds(100));
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();
}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 until specified time point has been reached (public member function) |
Please login to continue.