浅谈生产者消费者模型（Linux系统下的两种实现方法）

浅谈⽣产者消费者模型（Linux系统下的两种实现⽅法）⽣产者消费者问题是同步问题中的⼀种常见情况，借⽤⼀下维基百科的话
⽣产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是⼀个多线程同步问题的经典案例。

该问题描述了两个共享固定⼤⼩缓冲区的线程——即所谓的“⽣产者”和“消费者”——在实际运⾏时会发⽣的问题。

⽣产者的主要作⽤是⽣成⼀定量的数据放到缓冲区中，然后重复此过程。

与此同时，消费者也在缓冲区消耗这些数据。

该问题的关键就是要保证⽣产者不会在缓冲区满时加⼊数据，消费者也不会在缓冲区中空时消耗数据。

第⼀种实现信号量配合互斥锁实现，这种⽅法很清晰简单
信号量：
信号量的特性如下：信号量是⼀个⾮负整数（车位数），所有通过它的线程/进程（车辆）都会将该整数减⼀（通过它当然是为了使⽤资源），当该整数值为零时，所有试图通过它的线程都将处于等待状态。

在信号量上我们定义两种操作： Wait（等待）和 Release（释放）。

当⼀个线程调⽤Wait操作时，它要么得到资源然后将信号量减⼀，要么⼀直等下去（指放⼊阻塞队列），直到信号量⼤于等于⼀时。

Release（释放）实际上是在信号量上执⾏加操作，对应于车辆离开停车场，该操作之所以叫做“释放”是因为释放了由信号量守护的资源。

wait, release在Linux下
int sem_wait(sem_t * sem);
int sem_post(sem_t * sem);
设定两个信号量，empty⽤来表⽰空槽的个数，full⽤来表⽰占有的个数
⽣产者在向任务队列⾥放资源时，调⽤sem_wait(&full)来检查队列是否已满，如果满的话，就阻塞，直到有消费者从⾥⾯取资源再苏醒，如果不满，就放资源，并通知消费者来取。

消费者在从任务队列⾥取资源时，调⽤sem_wait(&empty)来检查队列是否为空，如果空的话，就阻塞，直到有⽣产者向⾥⾯放资源再苏醒，如果不空，就取资源，并通知⽣产者来放。

⽽互斥锁仅仅是为了防⽌多个线程同时对队列进⾏操作，造成未知的结果。

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#define MAX 5 //队列长度
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t full; //填充的个数
sem_t empty; //空槽的个数
int top = 0; //队尾
int bottom = 0; //队头
void* produce(void* arg)
{
int i;
for ( i = 0; i < MAX*2; i++)
{
printf("producer is preparing data\n");
sem_wait(&empty);//若空槽个数低于0阻塞
pthread_mutex_lock(&mutex);
top = (top+1) % MAX;
printf("now top is %d\n", top);
pthread_mutex_unlock(&mutex);
sem_post(&full);
}
return (void*)1;
}
void* consume(void* arg)
{
int i;
for ( i = 0; i < MAX*2; i++)
{
printf("consumer is preparing data\n");
sem_wait(&full);//若填充个数低于0阻塞
pthread_mutex_lock(&mutex);
bottom = (bottom+1) % MAX;
printf("now bottom is %d\n", bottom);
pthread_mutex_unlock(&mutex);
sem_post(&empty);
}
return (void*)2;
}
int main(int argc, char *argv[])
{
pthread_t thid1;
pthread_t thid2;
pthread_t thid3;
pthread_t thid4;
int ret1;
int ret2;
int ret3;
int ret4;
sem_init(&full, 0, 0);
sem_init(&empty, 0, MAX);
pthread_create(&thid1, NULL, produce, NULL);
pthread_create(&thid2, NULL, consume, NULL);
pthread_create(&thid3, NULL, produce, NULL);
pthread_create(&thid4, NULL, consume, NULL);
pthread_join(thid1, (void**)&ret1);
pthread_join(thid2, (void**)&ret2);
pthread_join(thid3, (void**)&ret3);
pthread_join(thid4, (void**)&ret4);
return 0;
}
注：如果把sem_wait()和sem_post()放到pthread_mutex_lock()与pthread_mutex_unlock()之间会如何呢？
答案是：死锁，因为我们不能预知线程进⼊共享区顺序，如果消费者线程先对mutex加锁，并进⼊，sem_wait()发现队列为空，阻塞，⽽⽣产者在对mutex加锁时，发现已上锁也阻塞，双⽅永远⽆法唤醒对⽅。

第⼆种是条件变量配合互斥锁实现
条件变量的常见⽤法是在不满⾜某些条件时，阻塞⾃⼰，直到有线程通知⾃⼰醒来。

⽽互斥量在这⾥的作⽤依然还是防⽌多线程对共享资源同时操作，造成未知结果。

⽣产者消费者的⾏为与之前相同，只不过原来只调⽤sem_wait()可以完成两步，1是检查条件，2是阻塞，现在条件变量需要我们⾃⼰来设定条件(所以说条件变量配合互斥锁⽐信号量的功能更强⼤，因为它可以⾃定义休眠条件，但是这对使⽤者的要求也提⾼了，必须理清逻辑关系避免死锁)
#include <stdio.h>
#include <pthread.h>
#define MAX 5
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t notfull = PTHREAD_COND_INITIALIZER; //是否队满
pthread_cond_t notempty = PTHREAD_COND_INITIALIZER; //是否队空
int top = 0;
int bottom = 0;
void* produce(void* arg)
{
int i;
for ( i = 0; i < MAX*2; i++)
{
pthread_mutex_lock(&mutex);
while ((top+1)%MAX == bottom)
{
printf("full! producer is waiting\n");
pthread_cond_wait(¬full, &mutex);//等待队不满
}
top = (top+1) % MAX;
printf("now top is %d\n", top);
pthread_cond_signal(¬empty);//发出队⾮空的消息
pthread_mutex_unlock(&mutex);
}
return (void*)1;
}
void* consume(void* arg)
{
int i;
for ( i = 0; i < MAX*2; i++)
{
pthread_mutex_lock(&mutex);
while ( top%MAX == bottom)
{
printf("empty! consumer is waiting\n");
pthread_cond_wait(¬empty, &mutex);//等待队不空
}
bottom = (bottom+1) % MAX;
printf("now bottom is %d\n", bottom);
pthread_cond_signal(¬full);//发出队不满的消息
pthread_mutex_unlock(&mutex);
}
return (void*)2;
}
int main(int argc, char *argv[])
{
pthread_t thid1;
pthread_t thid2;
pthread_t thid3;
pthread_t thid4;
int ret1;
int ret2;
int ret3;
int ret4;
pthread_create(&thid1, NULL, produce, NULL);
pthread_create(&thid2, NULL, consume, NULL);
pthread_create(&thid3, NULL, produce, NULL);
pthread_create(&thid4, NULL, consume, NULL);
pthread_join(thid1, (void**)&ret1);
pthread_join(thid2, (void**)&ret2);
pthread_join(thid3, (void**)&ret3);
pthread_join(thid4, (void**)&ret4);
return 0;
}
注：
为什么信号量在互斥区外，⽽条件变量在互斥区内呢？
因为互斥锁本质上是⼆元信号量，和信号量互斥的原理相同，⽽且放在互斥区会死锁，⽽条件变量是和互斥锁协同配合的，我们从pthread_cond_wait()和pthread_cond_signal()的内部实现就可以看出
pthread_cond_wait()是先将互斥锁解开，并陷⼊阻塞，直到pthread_signal()发出信号后pthread_cond_wait()再加上锁，然后退出，可以看到它们在设计时就是为了协同配合，⽽互斥锁和信号量都是由Linux下的futex机制实现的，这⾥就不展开说了
这⾥贴出了pthread_wait()源码图
以上就是⼩编为⼤家带来的浅谈⽣产者消费者模型(Linux系统下的两种实现⽅法)全部内容了，希望⼤家多多⽀持~。