NAME

std::this_thread::sleep_until - std::this_thread::sleep_until

Synopsis

Defined in header <thread>
template< class Clock, class Duration >
void sleep_until( const std::chrono::time_point<Clock,Duration>& (since C++11)
sleep_time );

Blocks the execution of the current thread until specified sleep_time has been
reached.

Clock must meet the Clock requirements.
The programs is ill-formed if std::chrono::is_clock_v<Clock> is false
(since C++20).

The standard recommends that the clock tied to sleep_time be used, in which case
adjustments of the clock may be taken into account. Thus, the duration of the block
might, but might not, be less or more than sleep_time - Clock::now() at the time of
the call, depending on the direction of the adjustment and whether it is honored by
the implementation. The function also may block for longer than until after
sleep_time has been reached due to scheduling or resource contention delays.

Parameters

sleep_time - time to block until

Return value

(none)

Exceptions

Any exception thrown by Clock or Duration (clocks and durations provided by the
standard library never throw)

Example

// Run this code

#include <iostream>
#include <chrono>
#include <thread>

auto now() { return std::chrono::steady_clock::now(); }

auto awake_time() {
using std::chrono::operator""ms;
return now() + 2000ms;
}

int main()
{
std::cout << "Hello, waiter...\n" << std::flush;
const auto start {now()};
std::this_thread::sleep_until(awake_time());
std::chrono::duration<double, std::milli> elapsed {now() - start};
std::cout << "Waited " << elapsed.count() << " ms\n";
}

Output:

Hello, waiter...
Waited 2000.17 ms