std::condition_variable_any::wait_until - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::condition_variable_any::wait_until

From cppreference.com
< cpp‎ | thread‎ | condition variable any

[edit template]

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.

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 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)
2) Equivalent to

    while (!pred()) {
        if (wait_until(lock, abs_time) == std::cv_status::timeout) {
            return pred();
        }
    }
    return true;

This overload may be used to ignore spurious wakeups.

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)

### [edit] 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: bool pred();​

### [edit] Return value

1) std::cv_status::timeout if the absolute timeout specified by `abs_time` was reached, std::cv_status::no_timeout overwise.
2) 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`.

### [edit] Exceptions

1)

May throw std::system_error, may also propagate exceptions thrown by lock.lock() or lock.unlock(). | (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)

2) Same as (1) but may also propagate exceptions thrown by `pred`

### [edit] 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.

The effects of `notify_one()`/`notify_all()` and each of the three atomic parts of `wait()`/`wait_for()`/`wait_until()` (unlock+wait, wakeup, and lock) take place in a single total order that can be viewed as modification order of an atomic variable: the order is specific to this individual condition_variable. This makes it 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.

### [edit] Example

Run this code

    #include <iostream>
    #include <atomic>
    #include <condition_variable>
    #include <thread>
    #include <chrono>
    using namespace std::chrono_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

### [edit] See also

wait | blocks the current thread until the condition variable is woken up (public member function) [edit]
wait_for | blocks the current thread until the condition variable is woken up or after the specified timeout duration (public member function) [edit]
C documentation for cnd_timedwait

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/thread/condition_variable_any/wait_until&oldid=90359"
Hidden category:

- Pages with unreviewed LWG DR marker