生产者消费者问题 这是一个非常经典的多线程题目，题目大意如下：有一个生产者在生产产品，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，在两者之间设置一个有多个缓冲区的缓冲池，生产者

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


#define BUFFER_SIZE 16


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 *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;
}


void put(struct prodcons *b,int data)
{
    pthread_mutex_lock(&b->lock);
    if((b->writepos + 1) % BUFFER_SIZE == b->readpos)
    {
        pthread_cond_wait(&b->notfull,&b->lock);
    }
    b->buffer[b->writepos] = data;
    b->writepos++;
    if(b->writepos >= BUFFER_SIZE)
    {
        b->writepos = 0;
    }
    pthread_cond_signal(&b->notempty);
    pthread_mutex_unlock(&b->lock);
}


int get(struct prodcons *b)
{
    int data;
    pthread_mutex_lock(&b->lock);
    if(b->writepos == b->readpos)
    {
        pthread_cond_wait(&b->notempty,&b->lock);
    }


    data = b->buffer[b->readpos];
    b->readpos++;
    if(b->readpos >= BUFFER_SIZE)
    {
        b->readpos = 0;
    }
    pthread_cond_signal(&b->notfull);
    pthread_mutex_unlock(&b->lock);
    return data;
}


#define OVER -1


struct prodcons buffer;


 void * producer(void *data)
{
    int n;
    for(n = 0;n < 20;n++)
    {
        printf("%d----->\n",n);
        put(&buffer,n);
    }
    put(&buffer,OVER);
    return NULL;
}


void * consumer(void *data)
{
    int d;
    while(1)
    {
        d = get(&buffer);
        if(d == OVER)
            break;
        printf("----->%d\n",d);
    }
    return NULL;
}


int main()
{
    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;
}