生产者消费者问题

生产者消费者模型：

在实际的软件开发过程中，经常会碰到如下场景：某个模块负责产生数据，这些数据

由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程

等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。

    单单抽象出生产者和消费者，还够不上是生产者／消费者模式。该模式还需要

有一个缓冲区处于生产者和消费者之间，作为一个中介。生产者把数据放入缓冲区，

而消费者从缓冲区取出数据。大概的结构如下图。

                    



为了不至于太抽象，我们举一个寄信的例子（虽说这年头寄信已经不时兴，但这个例

子还是比较贴切的）。

假设你要寄一封平信，大致过程如下：

    1、你把信写好——相当于生产者制造数据

    2、你把信放入邮筒——相当于生产者把数据放入缓冲区

    3、邮递员把信从邮筒取出——相当于消费者把数据取出缓冲区

    4、邮递员把信拿去邮局做相应的处理——相当于消费者处理数据

优点：

    1.降低耦合

因为两者通过中间媒介缓冲区，所以耦合率降低，如果生产者/消费者代码有变化，

另一方受影响不大。

   2.支持并发（concurrency）

    生产者直接调用消费者的某个方法，还有另一个弊端。由于函数调用是同步的

（或者叫阻塞的），在消费者的方法没有返回之前，生产者只好一直等在那边。万一

消费者处理数据很慢，生产者就会浪费很多时间去等待。

    3.支持忙闲不均

    缓冲区还有另一个好处。如果制造数据的速度时快时慢，缓冲区的好处就体现

出来了。当数据制造快的时候，消费者来不及处理，未处理的数据可以暂时存在缓冲

区中。等生产者的制造速度慢下来，消费者再慢慢处理掉。

    为了充分复用，我们拿寄信的例子来说事。假设邮递员一次只能带走1000封
d592


信。万一某次碰上情人节（也可能是圣诞节）送贺卡，需要寄出去的信超过1000

封，这时候邮筒这个缓冲区就派上用场了。邮递员把来不及带走的信暂存在邮筒中，

等下次过来时再拿走。

   生产者消费者模型中三种关系：

     1.生产者和生产者（竞争关系）

     2.消费者和消费者（竞争关系）

     3.生产者和消费者（互斥与同步关系）

下面我们写个简单的例子，首先我们创建两个线程，线成1生产数据(PushFront)，

线程2消费（PopFront）数据，我们使用pthread_mutex_lock(&mylock)进行加锁

（互斥锁）保护，以保证互斥，生产数据时不能消费数据,消费数据时不能生产数

据。

好了，不多说我们直接上代码：

#include<stdio.h>
#include<assert.h>
#include<unistd.h>
#include<stdlib.h>
#include<pthread.h>
typedef struct Linknode
{
int _data;
struct Linknode* _next;
}node;

pthread_mutex_t mylock=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t mycond=PTHREAD_COND_INITIALIZER;

node* CreatNode(int data)
{
node* newNode=(node*)malloc(sizeof(node));
if(newNode==NULL){
perror("malloc failed\n");
return NULL;
}
newNode->_data=data;
newNode->_next=NULL;
return newNode;
}

void InitLink(node** _head)
{
*_head=CreatNode(0);
}

void PushFront(node *head,int data)
{
assert(head);
//	assert(data);
node* newNode=CreatNode(data);
newNode->_next=head->_next;
head->_next=newNode;
}

void del_node(node* del)
{
free(del);
del=NULL;
}
int IsEmpty(node* head)
{
assert(head);
if(head->_next){
return 0;
}
return 1;
}

void PopFront(node* head,int* data)
{
assert(head);
if(IsEmpty(head)>0){
printf("list is empty\n");
return;
}
else{
node* del=head->_next;
*data=del->_data;
head->_next=del->_next;
del_node(del);
}

}

void DisplayLink(node *head)
{

assert(head);
node *cur=head->_next;
while(cur){
printf("%d ",cur->_data);
cur=cur->_next;
}
printf("\n");
}

void DestroyLink(node *head)
{

int data=0;
assert(head);
while(!IsEmpty(head)){
PopFront(head,&data);
}
free(head);
head=NULL;
}

void testLink()
{

node *head=NULL;
InitLink(&head);
int i=0;
int data=0;
for(;i<10;++i){
PushFront(head,i);
DisplayLink(head);
}
for(i=0;i<10;++i){
PopFront(head,&data);
DisplayLink(head);
}
DestroyLink(head);
}

void *product_run(void *arg)
{
int data=0;
node *head=(node *)arg;
while(1){
usleep(1234567);
data=rand()%1000;

		//pthread_mutex_lock(&mylock);//加锁
PushFront(head,data);
//pthread_mutex_unlock(&mylock);//解锁
pthread_cond_signal(&mycond);
printf("product is done  data=%d\n",data);
}
}

void *consumer_run(void *arg)
{
int data=0;
node *head=(node *)arg;
while(1){
//pthread_mutex_lock(&mylock);//加锁
while(!IsEmpty(head))
{
pthread_cond_wait(&mycond,&mylock);
}
PopFront(head,&data);
//pthread_mutex_unlock(&mylock);//解锁
printf("consumer is done   data=%d\n",data);
}
}

void testMode()
{
node *head=NULL;
InitLink(&head);
pthread_t tid1;
pthread_t tid2;
pthread_create(&tid1,NULL,product_run,(void *)head);
pthread_create(&tid2,NULL,consumer_run,(void *)head);
pthread_join(tid1,NULL);
pthread_join(tid2,NULL);
DestroyLink(head);
pthread_mutex_destroy(&mylock);
pthread_cond_destroy(&mycond);

}
int main()
{
testLink();
testMode();
return 0;
}

运行结果：

1.未加锁前：（此时消费未完，便有生产）

   


2.加锁后（生产一个，消费一个）



     之前的图稍微有点问题（本人不小心上传错图了，还请大家多多包涵！），现已改正！

到此结束，谢谢！