C++

参考

<condition_variable>

condition_variable

类
<condition_variable>

std::condition_variable

class condition_variable;
条件变量
条件变量是一个对象，它能够阻塞调用线程，直到收到通知以恢复执行。

当调用其wait函数之一时，它会使用（一个互斥量上的）unique_lock来锁定线程。线程将保持阻塞状态，直到另一线程调用同一condition_variable对象上的通知函数唤醒它。

类型为condition_variable的对象总是使用unique_lock<mutex>进行等待：对于一个能与任何类型的可锁定类型一起工作的替代方案，请参阅condition_variable_any。

成员函数

（构造函数）
构造 condition_variable (public member function)
(析构函数)
销毁 condition_variable (public member function)

Wait functions

wait
等待直到通知 (公有成员函数)
wait_for
等待超时或直到通知 (public member function)
wait_until
等待直到通知或时间点 (public member function)

Notify functions

notify_one
通知一个 (public member function)
notify_all
通知全部 (public member function)

示例

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
34
35
36
37
 
// condition_variable example
#include <iostream>           // std::cout
#include <thread>             // std::thread
#include <mutex>              // std::mutex, std::unique_lock
#include <condition_variable> // std::condition_variable

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void print_id (int id) {
  std::unique_lock<std::mutex> lck(mtx);
  while (!ready) cv.wait(lck);
  // ...
  std::cout << "thread " << id << '\n';
}

void go() {
  std::unique_lock<std::mutex> lck(mtx);
  ready = true;
  cv.notify_all();
}

int main ()
{
  std::thread threads[10];
  // spawn 10 threads:
  for (int i=0; i<10; ++i)
    threads[i] = std::thread(print_id,i);

  std::cout << "10 threads ready to race...\n";
  go();                       // go!

  for (auto& th : threads) th.join();

  return 0;
}

可能的输出（线程顺序可能有所不同）

10 threads ready to race...
thread 2
thread 0
thread 9
thread 4
thread 6
thread 8
thread 7
thread 5
thread 3
thread 1