std::future<T>::wait_until

来自cppreference.com
< cpp‎ | thread‎ | future

 
 
并发支持库
线程
(C++11)
(C++20)
(C++20)
this_thread 命名空间
(C++11)
(C++11)
(C++11)
互斥
(C++11)
(C++11)  
通用锁管理
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
条件变量
(C++11)
信号量
闩与屏障
(C++20)
(C++20)
未来体
(C++11)
(C++11)
(C++11)
(C++11)
安全回收
(C++26)
(C++26)
风险指针





原子类型
(C++11)
(C++20)
原子类型的初始化
(C++11)(C++20 中弃用)
(C++11)(C++20 中弃用)
内存定序
原子操作的自由函数
原子标志的自由函数
 
 
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 的情况并抛出以 future_errc::no_state 为错误条件的 std::future_error

标准建议使用绑定到 timeout_time 的时钟来测量时间,而该时钟不需要是单调时钟。当该时钟的调节不连续时,不会对此函数的行为有任何保证,但既存实现会将 timeout_timeClock 转换到 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);
 
    // 做出花 1 秒完成的未来体
    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();
 
    // 做出花 5 秒完成的未来体
    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 << "等待 2 秒..." << 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 未完成!\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 未完成!\n";
 
    std::cout << "完成!\n";
}

可能的输出:

等待 2 秒...
f_completes: 9
f_times_out 未完成!
完成!

参阅

等待结果变得可用
(公开成员函数)
等待结果,如果在指定的超时间隔后仍然无法得到结果,则返回。
(公开成员函数)