# std::future<T>::wait_until

< cpp‎ | thread‎ | future

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` 为何返回。

若调用此函数前 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_time` 从 `Clock` 转换到 std::chrono::system_clock ，并委托 POSIX `pthread_cond_timedwait` 以令等待忠实于系统时钟，但非用户提供 `Clock` 的调节。任何情况下，由于调度或资源争议延迟，函数可能等待长于抵达 `timeout_time` 。

### 示例

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

    int main()
    {
        std::chrono::system_clock::time_point two_seconds_passed
            = std::chrono::system_clock::now() + std::chrono::seconds(2);

        // 做出花 1 秒完成的 future
        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 秒完成的 future
        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 | 等待结果，如果在指定的超时间隔后仍然无法得到结果，则返回。 (公开成员函数)