生产者与消费者模型

1 什么是生产者与消费者模型

生产者与消费者模型是一种编程模型,它用来解决生产者线程与消费者线程数据交互的问题,简单来说.现有一个生产者与消费者模型,该模型由生产者线程和消费者线程组成。 生产者线程指的是生产数据提供数据的线程,消费者线程指的是处理数据的线程。生产者线程生产好数据以后,将数据放到一个指定的地方,然后消费者线程拿走数据去处理。

2 生产者与消费者模型的应用场景

一个线程产生数据,另一个线程处理数据,用于两个线程间的数据交互。

3 生产者消费者模型的优点

**1. 解耦合:**生产者线程与消费者线程不需要直接接触,而是通过中间的数据缓冲区来进行数据交互,该数据缓冲区由该模型提供。
**2. 支持忙线不均:**当生产数据的速度和处理数据的速度不同步时,可暂时将数据存放在缓冲区以后,再处理。增加了弹性。
3. 支持并发: 支持多个线程的同时操作

4 生产者与消费者模型的实现:
要点总结
1个场所: 中间 的数据缓冲区
两种角色: 生产者线程和消费者线程: 一个生产数据,一个处理数据
三种关系: 生产者和生产者之间:互斥关系
消费者与消费者之间:互斥关系
生产者与消费者之间:同步+互斥关系

代码实现如下:

在这里插入代码片 pro_cond.cpp+  ⮀                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ⮂⮂ buffers 
    1 #include <iostream>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       
    2 #include <queue>
    3 #include <pthread.h>
    4 
    5 // 生产者消费者模型
    6 
    7 #define MAX_QUEUE   10
    8 class BlockQueue
    9 {
   10     private:
   11         std::queue<int> _queue;//提供 一个场所  用来存放数据  
   12         int _capacity;//用于限制队列中最大节点数量
   13         pthread_mutex_t _mutex;// 定义互斥锁  保证安全  
   14         pthread_cond_t   _cond_product;// 定义生产者条件变量
   15         pthread_cond_t   _cond_consumer;// 定义消费者条件变量
   16    public:
   17         //  1构造函数  初始化对象
   18         BlockQueue(int cap=MAX_QUEUE):_capacity(cap){
   19         pthread_mutex_init(&_mutex,NULL);
   20         pthread_cond_init(&_cond_product,NULL);
   21         pthread_cond_init(&_cond_consumer,NULL);
   22         }
   23 
   24         // 2 析构函数  回收资源
   25         ~BlockQueue(){
   26         pthread_mutex_destroy(&_mutex);
   27         pthread_cond_destroy(&_cond_product);
   28         pthread_cond_destroy(&_cond_consumer);
   29 
   30         }
   31         // 入队列
   32         bool QueuePush(int data)  {
   33           pthread_mutex_lock(&_mutex);
   34           //  入队例之前先判断 队列是否已经满了
  35           while(_queue.size()==_capacity){
   36             pthread_cond_wait(&_cond_product,&_mutex);
   37           }
   38           // 没有满 直接入队列
   39           _queue.push(data);
   40           // 数据放入以后,唤醒消费者
   41           pthread_cond_signal(&_cond_consumer);
   42           // 解锁
   43           pthread_mutex_unlock(&_mutex);
   44         }
   45 
   46          //  出队列
   47         bool QueuePop(int& data){
   48 
   49           pthread_mutex_lock(&_mutex);
   50           while(_queue.empty()){
   51             pthread_cond_wait(&_cond_consumer,&_mutex);
   52           }
   53           data=_queue.front();
   54           _queue.pop();
   55           pthread_cond_signal(&_cond_product);
   56           pthread_mutex_unlock(&_mutex);
   57 
   58         }
   59 
   60 };
   61 
   62 // 取数据
   63 void *thr_consumer(void *arg){
   64    BlockQueue *q=(BlockQueue*)arg;
   65    while(1){
   66    int data;
   67    q->QueuePop(data);
   68    std::cout<<"consumer:"<<pthread_self()<<"get data:"<<data<<"\n";
   69  }
   70   return NULL;
   71 
   72 }
   73 // 放数据
   74 void *thr_product(void *arg){
   75  BlockQueue *q=(BlockQueue*)arg;
   76  int i=0;
   77  while(1){
   78    q->QueuePush(i++);
   79  std::cout<<"product:"<<pthread_self()<<" get data:"<<i<<"\n";
   80  }
   81 
   82 
   83 
   84   return NULL;
   85 }
   86 
   87 int main(){
   88 pthread_t cond_tid[4],pro_tid[4];
   89 BlockQueue q;
   90 int ret;
   91 for(int i=0;i<4;++i){
   92   ret=pthread_create(&cond_tid[i],NULL,thr_consumer,(void*)&q);
   93   if(ret !=0){
   94     std::cout<<"thread create error\n";
   95     return -1;
   96   }
   97 }
   98 
   99 for(int i=0;i<4;++i){
  100   ret=pthread_create(&pro_tid[i],NULL,thr_product,(void*)&q);
  101   if(ret !=0){
  102     std::cout<<"thread create error\n";
  103     return -1;
  104   }
  105 }
  106 
  107 //  等待线程退出
  108 for(int i=0;i<4;++i){
  109   pthread_join(cond_tid[i],NULL);
  110 }
  111 for(int i=0;i<4;++i){
  112   pthread_join(pro_tid[i],NULL);
  113 }
  114 
  115   return 0;
  116 }
  117 

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页