Linux下生产者消费者问题（使用互斥锁和条件变量）

Linux下生产者消费者问题（使用互斥锁和条件变量）:

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#include "pthread.h"

#define BUFFER_SIZE 16

struct prodcons  

{  

int buffer[BUFFER_SIZE];  

pthread_mutex_t lock;  //mutex ensuring exclusive access to buffer

int readpos,writepos;  //position for reading and writing

pthread_cond_t notempty;  //signal when buffer is not empty

pthread_cond_t notfull;  //signal when buffer is not full

}; 

//initialize a buffer

void init(struct prodcons* b)  

{  

pthread_mutex_init(&b->lock,NULL);  

pthread_cond_init(&b->notempty,NULL);  

pthread_cond_init(&b->notfull,NULL);  

b->readpos = 0;  

b->writepos = 0;  

} 

//store an integer in the buffer

void put(struct prodcons* b, int data)  

{  

pthread_mutex_lock(&b->lock);  

//wait until buffer is not full

while((b->writepos+1)%BUFFER_SIZE == b->readpos)  

{  

printf("wait for not full\n");  

pthread_cond_wait(&b->notfull,&b->lock);  

}

b->buffer[b->writepos] = data;  

b->writepos++;

b->writepos %= BUFFER_SIZE;

pthread_cond_signal(&b->notempty); //signal buffer is not empty

pthread_mutex_unlock(&b->lock);  

}

//read and remove an integer from the buffer

int get(struct prodcons* b)  

{  

int data;  

pthread_mutex_lock(&b->lock);  

//wait until buffer is not empty

while(b->writepos == b->readpos)  

{  

printf("wait for not empty\n");  

pthread_cond_wait(&b->notempty,&b->lock);  

}

data=b->buffer[b->readpos];  

b->readpos++;

b->readpos %= BUFFER_SIZE;

pthread_cond_signal(&b->notfull);  //signal buffer is not full

pthread_mutex_unlock(&b->lock);  

return data;

}

#define OVER -1

struct prodcons buffer; 

void * producer(void * data)  

{  

int n;  

for(n=0; n<50; ++n)  

{

printf("put-->%d\n",n);  

put(&buffer,n);  

}  

put(&buffer,OVER);  

printf("producer stopped\n");  

return NULL;  

} 

void * consumer(void * data)  

{  

int n;  

while(1)  

{  

int d = get(&buffer);  

if(d == OVER) break;  

printf("get-->%d\n",d);  

}

printf("consumer stopped\n");  

return NULL;  

} 

int main()  

{  

pthread_t tha,thb;  

void * retval; 

init(&buffer);  

pthread_creare(&tha,NULL,producer,0);  

pthread_creare(&thb,NULL,consumer,0); 

pthread_join(tha,&retval);  

pthread_join(thb,&retval); 

return 0;  

}