生产者与消费者模型

一、模型简介

如图：一共有三种关系：生产者与生产者的互斥关系，消费者与消费者的互斥关系，生产者与消费者的互斥且同步关系。

两种角色：生产者（线程）与消费者（线程）

一个交易场所：仓库（一段内存空间，且可存可取）

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

1、我们这里用一个单链表当做那段共享内存，简单实现生产者消费者模型。

代码：

 1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<pthread.h>
  4 #include<time.h>
  5 
  6 typedef struct Node{
  7     int data;
  8     struct Node *next;
  9 }node_t,*node_p,**node_pp;
 10 
 11 node_p allocNode(int x){
 12     node_p p=(node_p)malloc(sizeof(node_t));
 13     if(NULL==p){
 14         perror("malloc");
 15         exit(1);
 16     }
 17 
 18     p->data=x;
 19     p->next=NULL;
 20     return p;
 21 }
 22 
 23 int isEmpty(node_p head){

 24     if(head->next==NULL)
 25         return 1;
 26     return 0;
 27 }
 28 
 29 void initList(node_pp head){
 30     *head=allocNode(0);
 31 }
 32 
 33 void listPush(node_p head,int x){
 34     node_p p=allocNode(x);
 35     p->next=head->next;
 36     head->next=p;
 37 }
 38 
 39 int listPop(node_p head,int *x){
 40     int ret=-1;
 41     if(!isEmpty(head)){
 42         node_p p=head->next;
 43         head->next=p->next;
 44         if(x!=NULL){
 45             *x=p->data;
 46         }

 47         free(p);
 48         ret=0;
 49     }
 50     return ret;
 51 }
 52 
 53 void showList(node_p head){
 54     if(!isEmpty(head)){
 55         head=head->next;
 56         while(head){
 57             printf("%d ",head->data);
 58             head=head->next;
 59         }
 60     }
 61     printf("\n");
 62 }
 63 
 64 void destroyList(node_p head){
 65     while(!isEmpty(head)){
 66         listPop(head,NULL);
 67     }
 68 }

2、锁

同步的最常见方法是使用锁，锁是一种非强制机制，每一个线程在访问数据或资源之前先试图获取锁，并在访问结束之后释放锁，在锁已经被占用时试图获取锁时，线程会等待，直到锁重新可用。

看一下有关函数

lock用宏初始化。

pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;

3、条件变量