条件变量实例：生产者-消费者模式的后进先出型(std::stack)缓冲区

综合应用boost::thread库（thread, mutex, condition_variable_any）实现的 生产者-消费者模式

后进先出型(std::stack)缓冲区

stack可以经过轻微修改使用队列替换。

#include <boost/thread.hpp>
using namespace boost;

#include <stack>
#include <iostream>
using std::stack;
using std::cout;
using std::endl;

//生产者-消费者模式的后进先出型(std::stack)缓冲区
class Buffer
{
public:
//构造函数
Buffer(size_t n) :un_read(0), capacity(n){}

//写入数据x
void put(int x){
//局部域
{
mutex::scoped_lock lock(mu);  //锁定互斥量
while (is_full()){
cond_put.wait(mu);  //条件变量等待
}
stk.push(x);  //写入数据
++un_read;
}  //解锁互斥量

cond_get.notify_one();  //通知可以读取数据
}

//读取数据
void get(int *x){

{
mutex::scoped_lock lock(mu);
while (is_empty()){
cond_get.wait(mu);
}
*x = stk.top();
stk.pop();
--un_read;
}

cond_put.notify_one();
}

private:
//判断缓冲区是否满
bool is_full(){
return un_read == capacity;
}

//判断缓冲区是否为空
bool is_empty(){
return un_read == 0;
}

private:
mutex mu;  //互斥量，配合条件变量使用
condition_variable_any cond_put;  //写入条件变量
condition_variable_any cond_get;  //读取条件变量
stack<int> stk;  //缓冲区对象
int un_read;
int capacity;
};

Buffer buf(5);  //定义一个缓冲区对象

mutex io_mu_;  //定义一个输出互斥量

//生产者,n个
void producer(int n)
{
for (int i = 0; i < n; i++){
//输出信息
{
mutex::scoped_lock lock(io_mu_);
cout << "put " << i <<" to buffer"<< endl;

}
buf.put(i);  //写入数据
}
}

//消费者
void consumer(int n)
{
int result(0);
for (int i = 0; i < n; i++){
{
buf.get(&result);  //读取数据
mutex::scoped_lock lock(io_mu_);
cout << "get " << result << " from buffer" << endl;
}
}
}

void producer_consumer_test()
{
thread t_producer(producer, 20);
thread t_consumer1(consumer, 10);
thread t_consumer2(consumer, 10);

t_producer.join();
t_consumer1.join();
t_consumer2.join();
}

运行结果为：