Linux生产者消费者模型实现

生产者——消费者模型顾名思义，就是一个或多个线程往仓库生产东西，另外的线程从仓库拿东西，在咱们的线程池中也有所应用。咱们看看维基的解释：

生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了共享固定大小缓冲区的两个线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。

说了这么多，大家还是有点晕乎乎的，咱们看代码吧

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

//1 : 1

#define MAX_COUNT 20
#define MAX_BUFFER_SIZE 8
#define OVER -1

typedef struct pc_st
{
    int buffer[MAX_BUFFER_SIZE];  //共享的缓冲区，在我们实现的时候把其当成循环队列来操作
    pthread_mutex_t mutex;  //互斥锁用于实现线程的同步
    pthread_cond_t  notfull;  //条件变量，当该条件满足后唤醒生产者
    pthread_cond_t notempty;  //条件变量，当该条件满足后唤醒消费者
    int write_pos;  //写的下标
    int read_pos;  //读的下标
}pc_st;

pc_st  pc;

void init_pc(pc_st *p)  //初始化函数
{
    memset(p->buffer, 0, sizeof(p->buffer));
    pthread_mutex_init(&p->mutex, NULL);
    pthread_cond_init(&p->notfull, NULL);
    pthread_cond_init(&p->notempty, NULL);
    p->write_pos = 0;
    p->read_pos = 0;
}
void destroy_pc(pc_st *p)  //摧毁函数
{
    pthread_mutex_destroy(&p->mutex);
    pthread_cond_destroy(&p->notfull);
    pthread_cond_destroy(&p->notempty);
    p->write_pos = 0;
    p->read_pos = 0;
}

void put(pc_st *p, int val)  //用于往缓冲区放字符
{
    pthread_mutex_lock(&p->mutex);
    if((p->write_pos + 1) % MAX_BUFFER_SIZE == p->read_pos)
    {
        printf("仓库已满，暂停生产\n");

        pthread_cond_wait(&p->notfull, &p->mutex);
    }
    p->buffer[p->write_pos++] = val;
    p->write_pos = p->write_pos % MAX_BUFFER_SIZE;
    pthread_cond_signal(&p->notempty);
    pthread_mutex_unlock(&p->mutex);
}
int get(pc_st *p)  //用于从缓冲区拿字符
{
    pthread_mutex_lock(&p->mutex);
    if(p->read_pos == p->write_pos)
    {
        printf("仓库已空，暂停消费\n");
        pthread_cond_wait(&p->notempty, &p->mutex);
    }
    int val = p->buffer[p->read_pos++];
    p->read_pos = p->read_pos % MAX_BUFFER_SIZE;
    pthread_cond_signal(&p->notfull);

    pthread_mutex_unlock(&p->mutex);
    return val;
}

void* producer(void *arg) //生产者
{
    int i;
    for(i=1; i<=MAX_COUNT; ++i)
    {
        put(&pc, i);
    }
    put(&pc, OVER);
}
void* consumer(void *arg)  //消费者
{
    int value;
    while(1)
    {
        value = get(&pc);
        if(value == OVER)
            break;
        printf("value = %d\n",value);
    }
}

int main()
{
    init_pc(&pc);
    pthread_t pro_id, con_id;
    pthread_create(&pro_id, NULL, producer, NULL);
    sleep(1);
    pthread_create(&con_id, NULL, consumer, NULL);

    pthread_join(pro_id, NULL);
    pthread_join(con_id, NULL);

    destroy_pc(&pc);

    return 0;
}

运行示例：

解释一下：最开始的那个仓库已满是因为最先调用的是生产者，在消费者还没有从缓冲区拿东西的时候生产者已经把缓冲区填满而出现的提示