线程的互斥锁和条件变量通信机制

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <pthread.h>

#define BUFFER_SIZE 2
struct prodcons
{
    int buffer[BUFFER_SIZE];
    pthread_mutex_t lock;
    int readpos,writepos;
    pthread_cond_t notempty;
    pthread_cond_t notfull;
};

void init(struct prodcons *prod)
{
    pthread_mutex_init(&prod->lock,NULL);
    pthread_cond_init(&prod->notempty,NULL);
    pthread_cond_init(&prod->notfull,NULL);
    prod->readpos=0;
    prod->writepos=0;
}

void put(struct prodcons *prod, int data)
{
    pthread_mutex_lock(&prod->lock);
    while((prod->writepos+1)%BUFFER_SIZE==prod->readpos)
    {
        printf("producer wait for not full
");
        pthread_cond_wait(&prod->notfull,&prod->lock);
    }
    prod->buffer[prod->writepos]=data;
    prod->writepos++;
    if(prod->writepos>=BUFFER_SIZE)
        prod->writepos=0;
    pthread_cond_signal(&prod->notempty);
    pthread_mutex_unlock(&prod->lock);
}

int get(struct prodcons *prod)
{
    int data;
    pthread_mutex_lock(&prod->lock);
    while(prod->writepos==prod->readpos)
    {
        printf("consumer wait for not empty
");
        pthread_cond_wait(&prod->notempty,&prod->lock);
    }
    data=prod->buffer[prod->readpos];
    prod->readpos++;
    if(prod->readpos>=BUFFER_SIZE)
        prod->readpos=0;
    pthread_cond_signal(&prod->notfull);
    pthread_mutex_unlock(&prod->lock);
    return data;
}

#define OVER (-1)

struct prodcons buffer;

void *producer(void * data)
{
    int n;
    for(n=1;n<=5;n++)
    {
        printf("producer sleep 1 second...
");
        sleep(1);
        printf("put the %d product
",n);
        put(&buffer,n);
    }
    for(n=6;n<=10;n++)
    {
        printf("producer sleep 3 second...
");
        sleep(3);
        printf("put the %d product
",n);
        put(&buffer,n);
    }
    put(&buffer,OVER);
    printf("producer stopped
");
    return NULL;
}

void *consumer(void *data)
{
    int d=0;
    while(1)
    {
        printf("consumer sleep 2 second...
");
        sleep(2);
        d=get(&buffer);
        printf("get the %d product
",d);
        if(d==OVER)
            break;
    }
    printf("consumer stopped
");
    return NULL;
}

int main(int argc, char *argv[])
{
    pthread_t th_a,th_b;
    void *retval;
    init(&buffer);
    pthread_create(&th_a,NULL,producer,0);
    pthread_create(&th_b,NULL,consumer,0);
    pthread_join(th_a,&retval);
    pthread_join(th_b,&retval);
    return 0;
}