公有成员函数
<future>

std::future::wait_for

template <class Rep, class Period>  future_status wait_for (const chrono::duration<Rep,Period>& rel_time) const;
等待就绪,持续一段时间
等待指定时间段 rel_time 以内,使*共享状态*就绪。

如果*共享状态*尚未就绪(即,提供者尚未设置其值或异常),则该函数将阻塞调用线程,直到其*就绪*或直到 rel_time 时间已过,以先发生的为准。

当函数因其*共享状态*就绪而返回时,*共享状态*上设置的值或异常不会被读取,但所有可见的副作用将在提供者使*共享状态*就绪的那一点与此函数返回之间同步。

如果*共享状态*包含一个*延迟函数*(例如由 async 返回的 future 对象),则该函数不会阻塞,而是立即返回,返回值为 future_status::deferred

参数

rel_time
等待时间段,此后函数将返回并恢复调用线程的执行。
请注意,多线程管理操作可能会导致超过此时间的延迟。
duration 是一个代表特定*相对时间*的对象。

返回值

一个 future_status 类型的值,指示导致函数返回的原因
描述
future_status::ready共享状态 已就绪:生产者已设置值或异常。
future_status::timeout函数等待 rel_time 时间,而*共享状态*未就绪。
future_status::deferred共享状态 包含 延迟函数

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// future::wait_for
#include <iostream>       // std::cout
#include <future>         // std::async, std::future
#include <chrono>         // std::chrono::milliseconds

// a non-optimized way of checking for prime numbers:
bool is_prime (int x) {
  for (int i=2; i<x; ++i) if (x%i==0) return false;
  return true;
}

int main ()
{
  // call function asynchronously:
  std::future<bool> fut = std::async (is_prime,700020007); 

  // do something while waiting for function to set future:
  std::cout << "checking, please wait";
  std::chrono::milliseconds span (100);
  while (fut.wait_for(span)==std::future_status::timeout)
    std::cout << '.';

  bool x = fut.get();

  std::cout << "\n700020007 " << (x?"is":"is not") << " prime.\n";

  return 0;
}

可能的输出(可能需要更多或更少的时间)

checking, please wait..........................................
700020007 is prime.


数据竞争

访问了 future 对象。
共享状态 作为 原子操作 被访问(不会导致数据竞争)。

异常安全

在*未有效*的 future 对象上调用此成员函数,会产生*未定义行为*(尽管库实现可能会检测到这一点并抛出带有 no_state *错误条件*的 future_error,提供强担保)。

如果与 rel_time 相关的操作抛出异常,则此函数可能抛出异常(请注意,在 <chrono> 中提供的*时长*类型(如 seconds)上的操作永远不会抛出异常)。

另见