【Linux】生产者 消费者模型

blockQueue.hpp

#pragma once 
#include<iostream>
#include<pthread.h>
#include<queue>
using namespace std;

const int gcap=5;
template<class T>
class BlockQueue //阻塞队列
{
    public:
    BlockQueue(const int cap=gcap)
    :_cap(cap)
    {
        pthread_mutex_init(&_mutex,nullptr);
        pthread_cond_init(&_consumercond,nullptr);
         pthread_cond_init(&_productorcond,nullptr);
    }
    ~BlockQueue()
    {
         pthread_mutex_destroy(&_mutex);
         pthread_cond_destroy(&_consumercond);
         pthread_cond_destroy(&_productorcond);
    }
      void push(const T&in)
      {
          pthread_mutex_lock(&_mutex);
          //若队列满了，就需要在条件变量中等待，并自动释放锁
          while(_q.size()==_cap)
          {
              pthread_cond_wait(&_productorcond,&_mutex);
          }
           _q.push(in);
           //队列中至少有一个数据 所以 唤醒消费者
           pthread_cond_signal(&_consumercond);
          pthread_mutex_unlock(&_mutex);
      }
      void pop( T*out)
      {
           pthread_mutex_lock(&_mutex);
           //若队列为空，则需要在条件变量中等待，并自动释放锁
           while(_q.empty())
           {
              pthread_cond_wait(&_consumercond,&_mutex);
           }
           *out=_q.front();
           _q.pop();
           //队列中至少有一个空位置  所以唤醒生产者
           pthread_cond_signal(&_productorcond);
           pthread_mutex_unlock(&_mutex);
      }
    private:
     queue<T> _q;
     int _cap;//容量
     pthread_mutex_t _mutex;//锁 提供对队列的保护
    pthread_cond_t _consumercond;//消费者对应的条件变量
    pthread_cond_t _productorcond;//生产者对应的条件变量
};

makefile

cp:main.cc
	g++ -o $@ $^ -std=c++11 -lpthread
./PHONY:clean
clean:
	rm -f cp

main.cc

#include"blockQueue.hpp"
#include<unistd.h>
#include<ctime>
 
 //消费者执行消费任务
 void*consumer(void*args)
 {
    BlockQueue<int>*bq=(BlockQueue<int>*)args;
    while(true)
    {
      sleep(1);
        int data=0;
        //1.将数据从blockqueue中获取 --获取到了数据
         bq->pop(&data);
        //2.结合某种业务逻辑，处理数据
        cout<<"consumer data :"<<data<<endl;
    }
 }

//生产者执行生产任务
 void*productor(void*args)
 {

  BlockQueue<int>*bq=(BlockQueue<int>*)args;
  while(true)
  {
    //1.通过某种渠道获取数据
     int data=rand()%10+1;//1-10
    //2.将数据推送到blockqueue中  --- 完成生产的任务  
      bq->push(data); 
      cout<<"productor data :"<<data<<endl;
  }
 }
 int main()
 {
    srand((uint64_t)time(nullptr)^ getpid());//随机数
   BlockQueue<int> *bq= new  BlockQueue<int>;

   //单生产和单消费
   pthread_t c,p;
   pthread_create(&c,nullptr,consumer,bq);//消费者
   pthread_create(&p,nullptr,productor,bq);//生产者

   pthread_join(c,nullptr);
   pthread_join(p,nullptr);
   delete bq;
    return 0;
 }