标签：生产者消费者
生产者消费者模型
生产者消费者模型是经典的模型，我们都知道，在实际的软件开发中，某个模块负责生产数据，某个模块负责处理数据，产生数据的模块，就形象地成为生产者，而处理数据的模块，被称为消费者。
我们知道，该模式还需要一个缓冲区处于生产者和消费者之间，作为一个中介，生产者把数据放入缓冲区，而消费者从缓冲区取出数据。
我们下面基于条件变量和互斥锁，写一个生产者消费者模型的例子：
代码如下：
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <pthread.h>
typedef int data_type;
typedef int* data_type_p;
pthread_cond_t cond;
pthread_mutex_t lock;
typedef struct node
{
data_type _data;
struct node *next;
}node_t,*node_p,**node_pp;
node_p head=NULL;
static node_p buy_node(data_type data)
{
node_p tmp=(node_p)malloc(sizeof(node_t));
if(tmp)
{
tmp->_data=data;
tmp->next=NULL;
return tmp;
}
return NULL;
}
void init_list(node_pp headp)
{
*headp=buy_node(0);
}
void push_node(node_p list,data_type data)
{
node_p tmp=buy_node(data);
node_p tail=list;
while(tail->next)
{
tail=tail->next;
}
tail->next=tmp;
}
void delete_node(node_p tmp)
{
if(tmp)
{
free(tmp);
tmp=NULL;
}
}
int pop_node(node_p list,data_type_p data_p)
{
if(NULL==list->next)
{
*data_p=-2;
return -2;
}
else
{
node_p tmp=list->next;
list->next=tmp->next;
*data_p=tmp->_data;
delete_node(tmp);
}
return 0;
}
void show_list(node_p list)
{
node_p start=list->next;
while(start)
{
printf("%d ",start->_data);
fflush(stdout);
start=start->next;
}
printf("\n");
}
void *product(void *arg)
{
int i=0;
while(1)
{
pthread_mutex_lock(&lock);
printf("product data:%d\n",i);
push_node(head,i++);
pthread_mutex_unlock(&lock);
printf("product done,wake up consumer...\n");
pthread_cond_signal(&cond);
sleep(3);
}
}
void *consumer(void *arg)
{
data_type _data;
while(1)
{
pthread_mutex_lock(&lock);
while (-2==pop_node(head,&_data))
{
pthread_cond_wait(&cond,&lock);
}
printf("consumer data:%d\n",_data);
pthread_mutex_unlock(&lock);
sleep(1);
}
}
int main()
{
init_list(&head);
pthread_cond_init(&cond,NULL);
pthread_mutex_init(&lock,NULL);
pthread_t tid1,tid2;
pthread_create(&tid1,NULL,product,NULL);
pthread_create(&tid2,NULL,consumer,NULL);
pthread_join(tid1,NULL);
pthread_join(tid2,NULL);
return 0；
}
从上面的代码我们可以看到，我们用一个链表作为缓冲区，生产者生产的数据尾插到链表里，消费者从链表头取数据。
运行结果如下：
从结果我们可以看到，生产者消费者之间很好的实现了同步与互斥功能，生产者生产一个数据，消费者就消费一个数据。
标签：生产者消费者
原文地址：http://10706198.blog.51cto.com/10696198/1767131
