在同一个进程地址空间内执行的两个或者多个进程。生产者和消费者使用N 个不同的缓冲区。

生产者进程生产物品，然后将物品放置在一个空缓冲区中供消费者进程消费。

消费者进程从缓冲区中获得物品，然后释放缓冲区。

生产者进程生产物品时，若无空缓冲区可用，

生产者进程必须等待消费者进程释放出一个空缓冲区；

消费者进程消费物品时，

若缓冲区为空，消费者进程将被阻塞，直到新的物品被生产出来。

使用三个信号量：

一个用以阻止生产者进程和消费者进程同时操作缓冲区列表 的互斥信号量，sem_t mutex

一个当生产者进程生产出一个物品时可以用它向消费者进程发出信号的信号量sem_t full

一个消费者进程释放出一个空缓冲区时可以用它向生产者进程发出信号的信号量sem_t empty

实验步骤：

互斥信号量值的描述：

初值为1，取值范围为（-1，0，1）。

当 mutex=1 时，表示两个进程皆未进入需要互斥的临界区；

当 mutex=0 时，表示有一个进程进入临界区运行，另外一个必须等待，改入阻塞队列；

当 mutex=-1时，表示有一个进程正在临界区运行，另一个进程因等待而阻塞在信号量队列中，需要被当前已在临界区运行的进程退出时唤醒

初始数据定义：

实验代码：

#include<stdio.h>

#include<semaphore.h>

#include <pthread.h>

#include <unistd.h>

#include <stdlib.h>

#include<time.h>

#include<stdbool.h>

#define p_num 6              //生产者的数量

#define c_num 5               //消费者的数量

#define M 4                //缓冲区的数量

int t1=2;              //生产者每t1 秒生产产品

int t2=1;              //消费者每t2 秒消费产品

sem_t mutex;                    //作为互斥信号量，初值设为1

sem_t full;                  //已用缓冲区数量，初值设为0

sem_t empty;                    //现有剩余缓存区，初值设为M

int buffer[M];                 //缓冲区

int pcount=10;                  //生产产品的总数量，作为计数器，的那个==0时，生产完毕结束所有生产者线程

int ccount=20;

int in=0;               //生产者生产位置

int out=0;                   //消费者消费位置

void *producer(void* arg)

{

srand(time(NULL));

int num=*((int*)arg);

while(1)

{

if(pcount==0) break;

else

{

pcount--;

sem_wait(&empty);

sem_wait(&mutex);

buffer[in]=rand()%100;

printf("生产者 %d 将生产的产品 “%d” 放入缓冲区 %d\n",num+1,buffer[in],in);

in=(in+1)%M;

sem_post(&full);

sem_post(&mutex);sleep(t1);

}

}

}

void *customer(void* arg)

{

int num=*((int*)arg);

while(1)

{

if(ccount==0) break;

else

{

ccount--;

sem_wait(&full);

sem_wait(&mutex);

printf("消费者 %d 将缓存区 %d 中的产品 “%d” 拿出\n",num+1,out,buffer[out]);

out=(out+1)%M;

sem_post(&empty);

sem_post(&mutex);sleep(t2);

}

}

}

void main()

{

pthread_t producer_pthread[p_num],consumer_pthread[c_num];

int num1[p_num],num2[c_num];

sem_init(&mutex,0,1);

sem_init(&empty,0,M);

sem_init(&full,0,0);

printf("生产产品的总数量：%d个\n",pcount);

printf("生产者数量：%d个\n",p_num);

printf("消费者数量：%d个\n",c_num);

printf("缓存区数量：%d个\n",M);

for(int i=0;i<p_num;i++)                 //创建N个生产者线程

{

num1[i]=i;                         //编号

pthread_create(&producer_pthread[i],NULL,producer,(void*)&num1[i]);

}

for(int i=0;i<c_num;i++)                  //创建N个消费者线程

{

num2[i]=i;

pthread_create(&consumer_pthread[i],NULL,customer,(void*)&num2[i]);

}

for(int i=0;i<p_num;i++)

{pthread_join(producer_pthread[i],NULL);}

for(int i=0;i<c_num;i++)

{pthread_join(consumer_pthread[i],NULL);}

sem_destroy(&mutex);

sem_destroy(&full);

sem_destroy(&empty);

}