std::future<T>::wait_until

template< class Clock, class Duration >
std::future_status wait_until( const std::chrono::time_point<Clock,Duration>& timeout_time ) const;

(с C++11)

wait_until ожидает, пока результат станет доступным. Он блокируется до тех пор, пока не будет достигнута заданная timeout_time, или результат станет доступным, что произойдёт первым. Значение возврата указывает, почему wait_until возвратилось.

Если будущее является результатом вызова async с ленивой оценкой, эта функция возвращается немедленно, не дожидаясь.

Поведение не определено, если valid() является false до вызова этой функции, или Clock не соответствует требованиям Clock. Программа неверна, если std::chrono::is_clock_v<Clock> является false.(с C++20)

Параметры

timeout_time

максимальная временная точка блокировки

Возвращаемое значение

Константа	Объяснение
`future_status::deferred`	Общий статус содержит отложенную функцию с ленивой оценкой, поэтому результат будет вычислен только при явном запросе
`future_status::ready`	Результат готов
`future_status::timeout`	Истекло время ожидания

Исключения

Любое исключение, сгенерированное часом, временной точкой или продолжительностью при выполнении (часы, временные точки и продолжительности, предоставляемые стандартной библиотекой, никогда не генерируют исключения).

Примечания

Реализации рекомендуется обнаруживать случай, когда valid() == false до вызова и выбрасывать std::future_error с состоянием ошибки future_errc::no_state.

Стандарт рекомендует использовать связанные с timeout_time часы для измерения времени; эти часы не обязаны быть монотонными. Нет гарантий относительно поведения этой функции, если часы корректируются прерывисто, но существующие реализации преобразуют timeout_time из Clock в std::chrono::system_clock и делегируют вызов POSIX pthread_cond_timedwait, чтобы ожидание учитывало корректировки системных часов, но не пользовательских Clock. В любом случае, функция также может ждать дольше, чем до тех пор, пока timeout_time не будет достигнута из-за задержек планирования или конкуренции за ресурсы.

Пример

#include <chrono>
#include <future>
#include <iostream>
#include <thread>
 
int main()
{
    std::chrono::system_clock::time_point two_seconds_passed
        = std::chrono::system_clock::now() + std::chrono::seconds(2);
 
    // Make a future that takes 1 second to complete
    std::promise<int> p1;
    std::future<int> f_completes = p1.get_future();
    std::thread([](std::promise<int> p1)
                { 
                    std::this_thread::sleep_for(std::chrono::seconds(1)); 
                    p1.set_value_at_thread_exit(9); 
                }, 
                std::move(p1)
    ).detach();
 
    // Make a future that takes 5 seconds to complete
    std::promise<int> p2;
    std::future<int> f_times_out = p2.get_future();
    std::thread([](std::promise<int> p2)
                { 
                    std::this_thread::sleep_for(std::chrono::seconds(5)); 
                    p2.set_value_at_thread_exit(8); 
                }, 
                std::move(p2)
    ).detach();
 
    std::cout << "Waiting for 2 seconds..." << std::endl;
 
    if (std::future_status::ready == f_completes.wait_until(two_seconds_passed))
        std::cout << "f_completes: " << f_completes.get() << "\n";
    else
        std::cout << "f_completes did not complete!\n";
 
    if (std::future_status::ready == f_times_out.wait_until(two_seconds_passed))
        std::cout << "f_times_out: " << f_times_out.get() << "\n";
    else
        std::cout << "f_times_out did not complete!\n";
 
    std::cout << "Done!\n";
}

Возможный вывод:

Waiting for 2 seconds...
f_completes: 9
f_times_out did not complete!
Done!

См. также

wait	ожидает, пока результат станет доступным (публичный член-функция)
wait_for	ожидает результат, возвращает, если он недоступен в течение заданной длительности ожидания (публичный член-функция)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/thread/future/wait_until