c++面试经验 | 锐捷网络嵌入式委培班 （二）Linux 生产者消费者模型

 先看代码

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
#include<semaphore.h>
#include<iostream>

using namespace std;

#define PRODUCER_NUM 2 //生产者数目
#define CONSUMER_NUM 2 //消费者数目
#define POOL_SIZE	 11  //缓冲池大小
int poolA[POOL_SIZE];	//缓冲区A
int poolB[POOL_SIZE];	//缓冲区B
int headA = 0;	//缓冲池读取指针
int rearA = 0; //缓冲池写入指针
int headB = 0;	//缓冲池读取指针
int rearB = 0; //缓冲池写入指针
sem_t	roomA_sem;		//同步信号信号量，表示缓冲区有可用空间
sem_t	productA_sem;		//同步信号量，表示缓冲区有可用产品
pthread_mutex_t mutexA;
sem_t	roomB_sem;		//同步信号信号量，表示缓冲区有可用空间
sem_t	productB_sem;		//同步信号量，表示缓冲区有可用产品
pthread_mutex_t mutexB;
int sizeA = 0;
int sizeB = 0;
void* producer_funA(void* arg)
{
	//int num = *(int*)arg;
	while (1)
	{
		sleep(1);
		sem_wait(&roomA_sem);
		pthread_mutex_lock(&mutexA);
		//生产者往缓冲池中写入数据
		poolA[rearA] = 1;
		rearA = (rearA + 1) % POOL_SIZE;
		printf("工厂生产了产品A\n");
		sizeA = (rearA - headA + POOL_SIZE) % POOL_SIZE;
		printf("产品A的数量 %d\n", sizeA);
		pthread_mutex_unlock(&mutexA);
		if (sizeA >= 6)//使库存处于5以上
		{
			sem_post(&productA_sem);
		}
		
	}
}

void* producer_funB(void* arg)
{
	//int num = *(int*)arg;
	while (1)
	{
		sleep(1);
		sem_wait(&roomB_sem);
		pthread_mutex_lock(&mutexB);
		//生产者往缓冲池中写入数据
		poolB[rearB] = 1;
		rearB = (rearB + 1) % POOL_SIZE;
		printf("工厂生产了产品B\n");
		sizeB = (rearB - headB + POOL_SIZE) % POOL_SIZE;
		printf("产品B的数量 %d\n", sizeB);
		pthread_mutex_unlock(&mutexB);
		if (sizeA >= 6)//根据题目要求
		{
			sem_post(&productB_sem);
		}

	}
}

void* consumer_fun(void* arg)
{
	int num = *(int*)arg;
	while (1)
	{
		int aorb = rand() % 2;//0 a 1 b 商店随机买A或B
		int data;
		sleep(5);//时间可以任意调 加快可以看出效果
		if (aorb==0)
		{
			sem_wait(&productA_sem);
			pthread_mutex_lock(&mutexA);
			//消费者从缓冲池读取数据
			data = poolA[headA];
			headA = (headA + 1) % POOL_SIZE;
			printf("商店 %d 买了产品A\n", num+1);
			sizeA = (rearA - headA + POOL_SIZE) % POOL_SIZE;
			printf("产品A的数量 %d\n", sizeA);
			pthread_mutex_unlock(&mutexA);
			sem_post(&roomA_sem);
		}
		else
		{
			sem_wait(&productB_sem);
			pthread_mutex_lock(&mutexB);
			//消费者从缓冲池读取数据
			data = poolB[headB];
			headB = (headB + 1) % POOL_SIZE;
			printf("商店 %d 买了产品B\n", num+1);
			sizeB = (rearB - headB + POOL_SIZE) % POOL_SIZE;
			printf("产品B的数量 %d\n", sizeB);
			pthread_mutex_unlock(&mutexB);
			sem_post(&roomB_sem);
		}
	}
}

int main()
{
	cout << getpid() << endl;
	pthread_t producer_id[PRODUCER_NUM];
	pthread_t consumer_id[CONSUMER_NUM];
	pthread_mutex_init(&mutexA, NULL);	//初始化互斥量
	sem_init(&roomA_sem, 0, POOL_SIZE - 1);	//初始化信号量room_sem为缓冲池大小
	pthread_mutex_init(&mutexB, NULL);	//初始化互斥量
	sem_init(&roomB_sem, 0, POOL_SIZE - 1);	//初始化信号量room_sem为缓冲池大小
	sem_init(&productA_sem, 0, 0);	//初始化信号量product_sem为0，开始时缓冲池中没有数据
	sem_init(&productB_sem, 0, 0);	//初始化信号量product_sem为0，开始时缓冲池中没有数据
	//创建生产者线程
	pthread_create(&producer_id[0], NULL, producer_funA, NULL);
	pthread_create(&producer_id[1], NULL, producer_funB, NULL);
	for (int i = 0; i < PRODUCER_NUM; i++)
	{
		int ret;
		//创建消费者线程
		ret = pthread_create(&consumer_id[i], NULL, consumer_fun, (void*)&i);
		if (ret != 0)
		{
			printf("consumer_id error");
			exit(0);
		}
		sleep(1);
	}
	for (int i = 0; i < PRODUCER_NUM; i++)
	{
		pthread_join(producer_id[i], NULL);//等待线程结束回收
		pthread_join(consumer_id[i], NULL);
	}

	return 0;
}

运行结果

思路

首先这道题考究互斥锁和同步信号量的使用

首先仓库的库存要控制到5-10份之间，因此仓库最大设置为10，所以我的room_sem信号量初始化大小为10，但POOL_SIZE为什么要设定为11呢，因为这里我选用循环队列的数据结构来储存商品

循环队列维护一个头指针和尾指针，循环队列的大小的求导公式为(rear - head + 队列大小) % 队列大小;当头尾指针的值相等时，我们无法判断循环队列是满还是空，所以我们需要一个额外的空间，不让两个指针出现重合的情况。

仓库库存要在5份以上，所以当库存大于等于6的时候，我才能让商店买走商品，所以表示商品库存的信号量需要当库存大于等于6的时候，才能开始增加。

买A的时候不影响B的生产的话，就是买A的时候我只获得A的锁，而不获取B的锁

死锁的情况

sem_wait(&roomA_sem);
pthread_mutex_lock(&mutexA);

//
pthread_mutex_lock(&mutexA);
sem_wait(&roomA_sem);

将这两句话反过来会导致死锁，因为当库存数量处在临界区时，也就是仓库满了时候，生产者如果先获取A锁，再等待仓库空出来的话，生产拿着A锁，消费者获取不到锁，买不了商品，就陷入了死循环，也就是死锁。