std::condition_variable_any::wait_until (3) - Linux Manuals

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

NAME

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

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

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