标签：解锁   更新   ==   移除   rod   notify   cto   size_t   one   

生产者 - 消费者（Producer-Consumer），也叫有限缓冲（Bounded-Buffer），是多线程同步的经典问题之一

头文件

#include 
#include 
#include 
#include 
#include 

有限缓冲类

class BoundedBuffer {
public:
  BoundedBuffer(const BoundedBuffer& rhs) = delete;
  BoundedBuffer& operator=(const BoundedBuffer& rhs) = delete;

  BoundedBuffer(std::size_t size)
      : begin_(0), end_(0), buffered_(0), circular_buffer_(size) {
  }

  void Produce(int n) {
    {
      std::unique_lock<:mutex> lock(mutex_);
      // 等待缓冲不为满。
      not_full_cv_.wait(lock, [=] { return buffered_  lock(mutex_);
    // 等待缓冲不为空。
    not_empty_cv_.wait(lock, [=] { return buffered_ > 0; });

    // 移除一个元素。
    int n = circular_buffer_[begin_];
    begin_ = (begin_ + 1) % circular_buffer_.size();

    --buffered_;

    // 通知前，手动解锁。
    lock.unlock();
    // 通知生产者。
    not_full_cv_.notify_one();
    return n;
  }

private:
  std::size_t begin_;
  std::size_t end_;
  std::size_t buffered_;
  std::vector circular_buffer_;
  std::condition_variable not_full_cv_;
  std::condition_variable not_empty_cv_;
  std::mutex mutex_;
};

生产者与消费者线程共享的缓冲。g_io_mutex 是用来同步输出的。

BoundedBuffer g_buffer(2);
boost::mutex g_io_mutex;

生产者

生产 100000 个元素，每 10000 个打印一次。

void Producer() {
  int n = 0;
  while (n  lock(g_io_mutex);
      std::cout 

消费者

每消费到 10000 的倍数，打印一次。

void Consumer() {
  std::thread::id thread_id = std::this_thread::get_id();

  int n = 0;
  do {
    n = g_buffer.Consume();
    if ((n % 10000) == 0) {
      std::unique_lock<:mutex> lock(g_io_mutex);
      std::cout 

主线程

int main() {
  std::vector<:thread> threads;

  threads.push_back(std::thread(&Producer));
  threads.push_back(std::thread(&Consumer));
  threads.push_back(std::thread(&Consumer));
  threads.push_back(std::thread(&Consumer));

  for (auto& t : threads) {
    t.join();
  }

  return 0;
}

【转】C++ 并发编程（五）：生产者 - 消费者

标签：解锁   更新   ==   移除   rod   notify   cto   size_t   one   

原文地址：https://www.cnblogs.com/wsl-hitsz/p/14645376.html