Std::condition_variable_any::wait_until (3) Linux Manual Page

std::condition_variable_any::wait_until – std::condition_variable_any::wait_until

Synopsis

template <class Lock, class Clock, class Duration>

std::cv_status(1)(since C++ 11)

    wait_until(Lock &lock,

               const std::chrono::time_point<Clock, Duration> &timeout_time);

template <class Lock, class Clock, class Duration, class Pred>

bool wait_until(Lock &lock, (2)(since C++ 11)

                                const std::chrono::time_point<Clock, Duration> &timeout_time,

                Pred pred);

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, timeout_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)

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
predicate which returns false if the waiting should be continued.
pred – The signature of the predicate function should be equivalent to the following:
bool pred();

Return value

1) std::cv_status::timeout if the absolute timeout specified by timeout_time was reached, std::cv_status::no_timeout overwise.
2) false if the predicate pred still evaluates to false after the timeout_time timeout expired, otherwise true. If the timeout had already expired, evaluates and returns the result of pred.

Exceptions

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

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.

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

std::condition_variable_any::wait_until (3) Linux Manual Page