生产者消费者模型

生产者消费者模型：      

          两个进程共享一个缓冲区，一个进程称为生产者，它向缓冲区里放数据，另一个进程称为消费者，他向缓冲区里取数据，当生产者向缓冲区里放数据是就必须进入挂起状态，

知道消费者从缓冲区中取走数据后生产者才能继续向缓冲区里放数据，同样当缓冲区中没有数据时，消费者进程就必须进入挂起休眠状态，直到生产者向缓冲区中放入数据时，消

费者才能唤醒继续从缓冲区中取数据。

         生产者与消费者是两种角色，存在于一个交易场所，彼此之间存在三种关系。

一个交易场所：内存中具有存储数据的一段有界的缓冲区；

两种角色：生产者就是向交易场（缓冲区）所放东西（数据）的人，消费者就是从交易场所取东西的人。

三种关系：生产者与生产者之间存在竞争（或互斥）关系

                    生产者与消费者之间存在互斥与同步关系

                    消费者与消费者之间存在互斥关系 

基于单链表的生产者消费者模型

      当使用链表模拟生产者消费者模型时，我们可以借助链表的插入来扮演生产者的角色，用链表的删除来充当消费者的角色，接下来我们采用链表的头插和头删操作来模拟 

放数据和取数据的过程

代码如下：

  1 #include<stdio.h>

  2 #include<stdlib.h>
  3 #include<pthread.h>
  4 typedef struct _list{
  5     struct _list *next;
  6     int _val;
  7 }product_list;
  8 product_list *head=NULL;
  9 static pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;
 10 static pthread_cond_t need_product=PTHREAD_COND_INITIALIZER;
 11 void init_list(product_list *list)
 12 {
 13     if(NULL!=list)
 14     {
 15         list->next=NULL;
 16         list->_val=8;
 17     }
 18 }
 19 void *consumer(void *_val)
 20 {
 21     product_list *p=NULL;
 22     for(;;)
 23     {
 24         pthread_mutex_lock(&lock);
 25         while(NULL==head)
 26         {
 27             pthread_cond_wait(&need_product,&lock);
 28         }
 29         p=head;
 30         head=head->next;
 31         p->next=NULL;
 32         pthread_mutex_unlock(&lock);
 33         printf("consum success,val is:%d\n",p->_val);
 34         free(p);
 35         p=NULL;
 36     }
 37     return NULL;

 38 }
 39 void *product(void *_val)
 40 {
 41     for(;;)
 42     {
 43         sleep(rand()%2);
 44         product_list *p=malloc(sizeof(product_list));
 45         pthread_mutex_lock(&lock);
 46         init_list(p);
 47         p->_val=rand()%1000;
 48         p->next=head;
 49         head=p;
 50         pthread_mutex_unlock(&lock);
 51         printf("call consumer! product success,val is:%d\n",p->_val);
 52         pthread_cond_signal(&need_product);
 53     }
 54 }
 55 int main()
 56 {
 57     pthread_t t_product;
 58     pthread_t t_consumer;
 59     pthread_create(&t_product,NULL,product,NULL);
 60     pthread_create(&t_consumer,NULL,consumer,NULL);
 61     pthread_join(t_product,NULL);
 62     pthread_join(t_consumer,NULL);
 63     return 0;
 64 }

运行结果：

            

           可以看出这是基于链表的后进先出的生产者消费者模型。      
 

基于循环队列的生产者消费者模型

   先用一幅图大概描述一下该模型：

       这其中涉及到信号量（semaphore）的有关知识，首先我们需要掌握什么是pv操作，pv操作时由p操作和v操作构成，他们都是原子操作（原子操作就是这个动 

作要么全做，要么全不做），对于信号量的具体操作如下所示：

p（s）:

（1）将信号量s的值进行减1操作；

（2）如果s>=0则该信号继续执行，否则该进程等待挂起，直到有新进程释放了，才能被唤醒。

v（s）:

（1）将信号量的值进行加1操作；

（2）如果s>0,则该进程继续执行，否则释放队列中第一个等待信号量的进程。

        我们借助信号量来实现环形队列的生产者消费者者两种角色之间的对资源的存取，其实队列的底层数据存储的方法就是一个数组，只要控制好对队头和队尾得相关计算就可以实现循环队列。

         要实现这种生产模式，这里还必须遵循以下规则：

1、生产者先运行

2、消费者永远不能追上消费者

3、生产者不能将消费者超过一圈

代码如下：

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 #include<pthread.h>
 4 #include<semaphore.h>

 5 #define _SEM_PRO_ 10
 6 #define _SEM_COM_ 0
 7 sem_t sem_product;
 8 sem_t sem_consume;
 9 int bank[_SEM_PRO_];
 10 void* consumer(void *_val)
 11 {
 12     int c=0;
 13     while(1)
 14     {
 15         sem_wait(&sem_consume);
 16         int _consume=bank[c];
 17         printf("consume done...,val is:%d\n",_consume);
 18         sem_post(&sem_product);
 19         c=(c+1)%_SEM_PRO_;
 20         sleep(rand()%5);
 21     }
 22 }
 23 void* producter(void *_val)
 24 {
 25     int p=0;
 26     while(1)
 27     {
 28         sem_wait(&sem_product);
 29         int _product=rand()%100;
 30         bank[p]=_product;
 31         printf("product done...,val is:%d\n,_product");
 32         sem_post(&sem_consume);
 33         p=(p+1)%_SEM_PRO_;
 34         sleep(rand()%3);
 35     }
 36 }

 37 void run_product_consume()
 38 {
 39     pthread_t tid_consumer;
 40     pthread_t tid_producter;
 41     pthread_create(&tid_consumer,NULL,consumer,NULL);
 42     pthread_create(&tid_producter,NULL,producter,NULL);
 43     pthread_join(tid_consumer,NULL);
 44     pthread_join(tid_producter,NULL);
 45 }
 46 void destroy_all_sem(int val)
 47 {
 48     printf("process done...\n");
 49     sem_destroy(&sem_product);
 50     sem_destroy(&sem_consume);
 51     exit(0);
 52 }
 53 void init_all_sem()
 54 {
 55     signal(2,destroy_all_sem);
 56     int bank[_SEM_PRO_];
 57     int _num=sizeof(bank)/sizeof(bank[0]);
 58     int i=0;
 59     for(;i<_num;i++)

 60       {

 61         bank[i]=0;
 62    }
 63     sem_init(&sem_product,0,_SEM_PRO_);
 64     sem_init(&sem_consume,0,_SEM_COM_);
 65 }
 66 int main()
 67{

 68     init_all_sem();
 69     run_product_consume();
 70     return 0;
 71 }

运行结果如下：