c++ 条件变量

参考cplusplus
参考cppreference

1.condition_variable

  • 为std::unique_lock提供条件变量

1.1 wait/ wait_for / wait_until

//unconditional (1) 
void wait (unique_lock<mutex>& lck);

//predicate (2) 
template <class Predicate>
  void wait (unique_lock<mutex>& lck, Predicate pred);
  • 条件变量工作过程：
    step1.调用者把锁住的lck传给函数，函数然后自动把线程放到等待条件的线程列表上，然后对lck进行解锁。
    step2.一旦条件变量满足，wait返回时，函数解除阻塞，病重新多lck进行加锁。
    如果指定了谓词pred，函数只在pred为false才阻塞，并且通知只有在pred为true的时候才能解除阻塞。
// condition_variable::wait (with predicate)
#include <iostream>           // std::cout
#include <thread>             // std::thread, std::this_thread::yield
#include <mutex>              // std::mutex, std::unique_lock
#include <condition_variable> // std::condition_variable

std::mutex mtx;
std::condition_variable cv;

int cargo = 0;
bool shipment_available() {return cargo!=0;}

void consume (int n) {
  for (int i=0; i<n; ++i) {
    std::unique_lock<std::mutex> lck(mtx);
    cv.wait(lck,shipment_available);
    // consume:
    std::cout << cargo << '\n';
    cargo=0;
  }
}

int main ()
{
  std::thread consumer_thread (consume,10);

  // produce 10 items when needed:
  for (int i=0; i<10; ++i) {
    while (shipment_available()) std::this_thread::yield();
    std::unique_lock<std::mutex> lck(mtx);
    cargo = i+1;
    cv.notify_one();
  }

  consumer_thread.join();

  return 0;
}

//unconditional (1) 
template <class Rep, class Period>
  cv_status wait_for (unique_lock<mutex>& lck,
                      const chrono::duration<Rep,Period>& rel_time);

//predicate (2) 
template <class Rep, class Period, class Predicate>
       bool wait_for (unique_lock<mutex>& lck,
                      const chrono::duration<Rep,Period>& rel_time, Predicate pred);
  • 版本1返回 cv_status::timeout或者cv_status::no_timeout；
    版本2返回pred()
// condition_variable::wait_for example
#include <iostream>           // std::cout
#include <thread>             // std::thread
#include <chrono>             // std::chrono::seconds
#include <mutex>              // std::mutex, std::unique_lock
#include <condition_variable> // std::condition_variable, std::cv_status

std::condition_variable 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): \n";
  std::thread th (read_value);

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

  th.join();

  return 0;
}

//unconditional (1) 
template <class Clock, class Duration>
  cv_status wait_until (unique_lock<mutex>& lck,
                        const chrono::time_point<Clock,Duration>& abs_time);

//predicate (2) 
template <class Clock, class Duration, class Predicate>
       bool wait_until (unique_lock<mutex>& lck,
                        const chrono::time_point<Clock,Duration>& abs_time,
                        Predicate pred);

1.2 notify_one / notify_all

void notify_one() noexcept;
  • 将等待该条件的一个线程取消阻塞。多余一个线程等待时，选择哪个线程是未指定的。
// condition_variable::notify_one
#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 produce,consume;

int cargo = 0;     // shared value by producers and consumers

void consumer () {
  std::unique_lock<std::mutex> lck(mtx);
  while (cargo==0) consume.wait(lck);
  std::cout << cargo << '\n';
  cargo=0;
  produce.notify_one();
}

void producer (int id) {
  std::unique_lock<std::mutex> lck(mtx);
  while (cargo!=0) produce.wait(lck);
  cargo = id;
  consume.notify_one();
}

int main ()
{
  std::thread consumers[10],producers[10];
  // spawn 10 consumers and 10 producers:
  for (int i=0; i<10; ++i) {
    consumers[i] = std::thread(consumer);
    producers[i] = std::thread(producer,i+1);
  }

  // join them back:
  for (int i=0; i<10; ++i) {
    producers[i].join();
    consumers[i].join();
  }

  return 0;
}

void notify_all() noexcept;

// condition_variable::notify_all
#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;
}

2.condition_variable_any

  • 为任何的lock类型提供条件变量
//unconditional (1) 
template <class Lock> void wait (Lock& lck);

//predicate (2) 
template <class Lock, class Predicate>
  void wait (Lock& lck, Predicate pred);

// condition_variable_any::notify_all
#include <iostream>           // std::cout
#include <thread>             // std::thread
#include <mutex>              // std::mutex
#include <condition_variable> // std::condition_variable_any

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

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

void go() {
  mtx.lock();
  ready = true;
  cv.notify_all();
  mtx.unlock();
}

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;
}

3.notify_all_at_thread_exit

void notify_all_at_thread_exit (condition_variable& cond, unique_lock<mutex> lck);
  • lck最好是右值
    在线程退出的时候类似于做了一下工作：
lck.unlock();
cond.notify_all()

// notify_all_at_thread_exit
#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);
  std::notify_all_at_thread_exit(cv,std::move(lck));
  ready = true;
}

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";

  std::thread(go).detach();   // go!

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

  return 0;
}

4.cv_status——前面有用到

enum class cv_status { no_timeout, timeout };
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

相关阅读更多精彩内容

  • c++11 多线程（4） condition_varible 总结
    接着上节 atomic，本节主要介绍condition_varible的内容，练习代码地址。本文参考http://...
    jorion阅读 8,639评论 0赞 7
  • std::condition_variable 详解
    <condition_variable > 头文件主要包含了与条件变量相关的类和函数。相关的类包括 std::co...
    张霸天阅读 3,891评论 1赞 0
  • C++11 多线程支持
    本文根据众多互联网博客内容整理后形成，引用内容的版权归原始作者所有，仅限于学习研究使用，不得用于任何商业用途。 互...
    深红的眼眸阅读 1,228评论 0赞 0
  • cpp11新特性详解与应用
    以下是我最近几个星期学习c++11做的一些记录，包括收集的一些信息，整理的相关概念和写的一些测试代码。具体相关代码...
    在河之简阅读 2,963评论 0赞 6
  • a-kah
    番客從馬來帶回的“agak”，漳州地區等多為“a-kah”，泉州地區有讀為“a-lah”，廈門等也有讀較像原本音讀...
    毋成囝阅读 449评论 1赞 2

友情链接更多精彩内容