C++

参考

<condition_variable>

condition_variable_any

public member function
<condition_variable>

std::condition_variable_any::wait_for

unconditional (1)
template <class Lock, class Rep, class Period>  cv_status wait_for (Lock& lck,                      const chrono::duration<Rep,Period>& rel_time);
predicate (2)
template <class Lock, class Rep, class Period, class Predicate>       bool wait_for (Lock& lck,                      const chrono::duration<Rep,Period>& rel_time, Predicate pred);
等待超时或直到收到通知
当前线程（应持有 lck 锁）的执行将被阻塞 rel_time 时间，或者直到收到通知（如果后者先发生）。

在线程阻塞时，函数会自动调用 lck.unlock()，允许其他已锁定的线程继续执行。

一旦收到通知或 rel_time 时间过去，函数将解除阻塞并调用 lck.lock()，使 lck 处于调用函数时的相同状态。然后函数返回（请注意，这个最后的互斥锁锁定可能会在返回前再次阻塞线程）。

通常，函数是通过另一线程调用成员函数 notify_one 或 notify_one 来唤醒的。但某些实现可能会在没有调用这些函数的情况下产生虚假唤醒。因此，此函数的使用者应确保其恢复条件得到满足。

如果指定了 pred (2)，则仅当 pred 返回 false 时函数才阻塞，并且只有在 pred 变为 true 时通知才能解除线程阻塞（这对于检查虚假唤醒特别有用）。它的行为就好像是这样实现的：
1
 
return wait_until (lck, chrono::steady_clock::now() + rel_time, std::move(pred));

参数

lck
当前被该线程锁定的一个可锁定对象。
所有对该对象的wait 成员函数的并发调用都必须使用相同的底层互斥锁对象。
Lock 应为可锁定类型。
rel_time
线程在等待通知期间可能阻塞的最大时间跨度。
duration 是一个表示特定相对时间的对象。
pred
一个可调用对象或函数，它不接受任何参数，并返回一个可以被评估为 bool 的值。
此函数会反复调用 pred，直到其求值为 true。

返回值

无条件版本 (1) 如果函数因为 rel_time 时间过去而返回，则返回 cv_status::timeout，否则返回 cv_status::no_timeout。
谓词版本 (2) 返回 pred()，而不管超时是否被触发（尽管它只有在被触发时才能为 false）。

示例

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
29
30
31
32
33
 
// condition_variable_any::wait_for example
#include <iostream>           // std::cout
#include <thread>             // std::thread
#include <chrono>             // std::chrono::seconds
#include <mutex>              // std::mutex
#include <condition_variable> // std::condition_variable_any, std::cv_status

std::condition_variable_any cv;

int value;

void read_value() {
  std::cin >> value;
  cv.notify_one();
}

int main ()
{
  std::cout << "Please, enter an integer (I'll be printing dots): ";
  std::thread th (read_value);

  std::mutex mtx;
  mtx.lock();
  while (cv.wait_for(mtx,std::chrono::seconds(1))==std::cv_status::timeout) {
    std::cout << '.';
  }
  std::cout << "You entered: " << value << '\n';
  mtx.unlock();

  th.join();

  return 0;
}

可能的输出

Please, enter an integer (I'll be priniting dots): .....20
You entered: 20


数据竞争

该函数执行三个原子操作：
  • 对 lck 的初始解锁和同时进入等待状态。
  • 解除等待状态。
  • 在返回前锁定 lck。
对对象的原子操作按照一个单一的总顺序进行排序，此函数中的三个原子操作以与上述相同的相对顺序发生。

异常安全

如果任何参数的值对此函数无效（例如，如果 lck 的互斥锁对象未被调用线程锁定），则会导致未定义行为。

否则，如果抛出异常，则 condition_variable_any 对象和参数都处于有效状态（基本保证）。

如果发生错误（将相应的对 lock 或 unlock 的调用传输的任何错误条件），则可能抛出 system_error。

谓词版本 (2) 也可能抛出由 pred 抛出的任何异常。

发生异常时，在退出函数作用域之前，会尝试恢复 lck 的状态（通过调用 lck.lock()）。
如果与 rel_time 相关的操作抛出异常，则可能抛出异常（请注意，<chrono> 中提供的 duration 类型（如 seconds）的操作永远不会抛出异常）。

谓词版本 (2) 也可能抛出由 pred 抛出的异常。

如果函数在某个时刻未能恢复锁定并返回（例如，如果尝试锁定或解锁时抛出异常），则会调用 std::terminate。

另见

condition_variable_any::wait_until
等待直到通知或时间点 (public member function)
condition_variable_any::wait
等待直到通知 (公有成员函数)
condition_variable_any::notify_one
通知一个 (public member function)
condition_variable_any::notify_all
通知全部 (public member function)