一、生产者消费者问题概述

生产者 / 消费者问题，也被称作有限缓冲问题。两个或者更多的线程共享同一个缓冲区，其中一个或多个线程作为 “ 生产者 ” 会不断地向缓冲区中添加数据，另一个或者多个线程作为 “ 消费者 ” 从缓冲区中取走数据。生产者 / 消费者模型关注的是以下几点：

1. 生产者和消费者必须互斥的使用缓冲区，即生产者添加数据的时候，消费者不能取走数据，同样消费者在取走数据的时候，生产者不能添加数据。

2.缓冲区空时，消费者不能读取数据

3.缓冲区满时，生产者不能添加数据

二、生产者消费者模型优点：

1. 解耦：因为多了一个缓冲区，所以生产者和消费者并不直接相互调用，这样生产者和消费者的代码发生变化，都不会对对方产生影响。这样其实就是把生产者和消费者之间的强耦合解开，变成了生产者和缓冲区，消费者和缓冲区之间的弱耦合

2. 支持并发：如果消费者直接从生产者拿数据，则消费者需要等待生产者生产数据，同样生产者需等待消费者消费数据。而有了生产者 / 消费者模型，生产者和消费者可以是两个独立的并发主体。生产者把制造出来的数据添加到缓冲区，就可以再去生产下一个数据了。而消费者也是一样的，从

缓冲区中读取数据，不需要等待生产者。这样，生产者和消费者就可以并发的执行。

3. 支持忙闲不均：如果消费者直接从生产者这里拿数据，而生产者生产数据很慢，消费者消费数据很快，或者生产者生产数据很多，消费者消费数据很慢。都会造成占用 CPU 的时间片白白浪费。生产者 / 消费者模型中，生产者只需要将生产的数据添加到缓冲区，缓冲区满了就不生产了。消费者从缓冲区中读取数据，缓冲区空了就不消费了，使得生产者 / 消费者的处理能力达到一个动态的平

衡。

三、生产者消费者模型实现

假定缓冲池中有 N 个缓冲区，一个缓冲区只能存储一个 int 类型的数据。定义互斥锁 mutex 实现对缓

冲区的互斥访问；计数信号量product 用来表示空闲缓冲区的数量，其初值为 N ；计数信号量consume 用来表示有数据的缓冲区的数量，其初值为 0

一下为画图表示

如图所示，有三个生产者，两个消费者（注意该图所指向仅表示写入数据，并不代表写入同一个空间，读取亦是），设置两个信号量用来控制生产者消费者的运行，首先注意不能先加锁，如果缓冲区满了，此时s1=0，p操作就会阻塞，以至于加锁后无法解锁，所以应该先p操作再加锁，加完锁后就可以开始写入数据，写完后解锁，然后给消费者的信号量+1，这样消费者就可以读取操作了。注意生产者消费者模型并不是生产者将数据生产完后，消费者才能读，是一边生产一边读取。

四、代码实现

根据三的图，我们可以用代码来实现该操作

4.1 信号量+互斥锁

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>
#include<semaphore.h>
#include<pthread.h>
#define BUFF_SIZE 10
sem_t product_sem;
sem_t consume_sem;
pthread_mutex_t mutex;
int buff[BUFF_SIZE];
int in=0;
int out=0;

void*pro_fun(void*arg)//生产者
{
    for(int i=0;i<20;i++)
    {
    sem_wait(&product_sem);
    pthread_mutex_lock(&mutex);
    buff[in]=rand()%100;
    printf("生产者在%d处产生数据%d\n",in,buff[in]);
    in=(++in)%10;
    pthread_mutex_unlock(&mutex);
    sem_post(&consume_sem);
    }
}
void*con_fun(void*arg)//消费者
{
    for(int i=0;i<30;i++)
    {
        sem_wait(&consume_sem);
        pthread_mutex_lock(&mutex);
        printf("----------消费者在%d处消费数据%d\n",out,buff[out]);
        out=(++out)%10;
        pthread_mutex_unlock(&mutex);
        sem_post(&product_sem);
    }
}
int main()
{
    sem_init(&product_sem,0,BUFF_SIZE);
    sem_init(&consume_sem,0,0);
    pthread_mutex_init(&mutex,NULL);
    srand((time(NULL)));
    pthread_t pro_id[3];
    for(int i=0;i<3;i++)
    {
         pthread_create(&pro_id[i],NULL,pro_fun,NULL);
    }
    pthread_t con_id[2];
    for(int i=0;i<2;i++)
    {
         pthread_create(&con_id[i],NULL,con_fun,NULL);
    }
    for(int i=0;i<3;i++)
    {
        pthread_join(pro_id[i],NULL);
    }
     for(int i=0;i<2;i++)
    {
        pthread_join(con_id[i],NULL);
    }
    sem_destroy(&product_sem);
    sem_destroy(&consume_sem);
    pthread_mutex_destroy(&mutex);
    exit(0);

}

该方法可以精确记录空闲和数据的个数。

4.2 条件变量

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>
#include<semaphore.h>
#include<pthread.h>
#define BUFF_SIZE 10

pthread_mutex_t mutex;
pthread_cond_t cond;
int buff[BUFF_SIZE];
int in = 0;
int out = 0;

void* pro_fun(void* arg) {
    for (int i = 0; i < 20; i++) {
        pthread_mutex_lock(&mutex);

        while ((in + 1) % BUFF_SIZE == out) {
            pthread_cond_wait(&cond, &mutex);
        }//如果生产者生产数据值满了，通知消费者

        buff[in] = rand() % 100;
        printf("生产者在%d处产生数据%d\n", in, buff[in]);
        in = (in + 1) % BUFF_SIZE;
        
        pthread_cond_signal(&cond);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

void* con_fun(void* arg) {
    for (int i = 0; i < 30; i++) {
        pthread_mutex_lock(&mutex);
        
        while (in == out) {
            pthread_cond_wait(&cond, &mutex);
        }//如果消费者消费完，通知生产者生产数据
        
        printf("----------消费者在%d处消费数据%d\n", out, buff[out]);
        out = (out + 1) % BUFF_SIZE;
        
        pthread_cond_signal(&cond);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main() {
    pthread_cond_init(&cond, NULL);
    pthread_mutex_init(&mutex, NULL);
    srand(time(NULL));

    pthread_t pro_id[3];
    for (int i = 0; i < 3; i++) {
        pthread_create(&pro_id[i], NULL, pro_fun, NULL);
    }

    pthread_t con_id[2];
    for (int i = 0; i < 2; i++) {
        pthread_create(&con_id[i], NULL, con_fun, NULL);
    }
    
    for (int i = 0; i < 3; i++) {
        pthread_join(pro_id[i], NULL);
    }
    for (int i = 0; i < 2; i++) {
        pthread_join(con_id[i], NULL);
    }

    pthread_cond_destroy(&cond);
    pthread_mutex_destroy(&mutex);

    exit(0);
}