C语言——生产者消费者问题

最新推荐文章于 2024-07-14 14:55:20 发布
最新推荐文章于 2024-07-14 14:55:20 发布
阅读量2.5w 收藏 47
点赞数 11
文章标签： c语言 编程语言 操作系统
原文链接：https://wenku.baidu.com/view/a8ba5388988fcc22bcd126fff705cc1755275faa.html?tdsourcetag=s_pcqq_aiomsg&qq-pf-to=pcqq.c2c
版权

百度文献查看原文

核心代码：

#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#include<string.h>
#include<windows.h>
#define dataBufferSize  2        //缓冲区数目
#define processNum 4            //进程数量(生产者、消费者进程总数目)
typedef struct Seamphore          //信号量
{       
int value;            //信号量的值
int *pcq;            //信号量队列指针
} Seamphore;
int producerCongestionQueue[processNum];    //等待信号量empty的阻塞队列
int consumerCongestionQueue[processNum];    //等待信号量full的阻塞队列
int shareCongestionQueue[processNum];        //等待信号量mutex的阻塞队列
Seamphore empty={dataBufferSize,producerCongestionQueue}; // empty：空缓冲区数目
Seamphore full={0,consumerCongestionQueue};  // full：缓冲区内可用的产品
Seamphore mutex={1,shareCongestionQueue};    //mutex：互斥信号量
struct DataBuffer          //缓冲区
{           
int buffer[dataBufferSize];   
int count;                //当前产品数量
}dataBuffer;
typedef struct Process          //进程PCB
{
char name[10];                //进程名
int roleFlag;                    //进程类型（1: 生产者  0: 消费者）
int currentState;              //进程状态（1: 就绪态  0: 阻塞态）
int currentStep;              //断点
int data;                        //临时数据
int code;                        //进程编号
}Process;
Process process[processNum];    //进程集合
void moveDataForward()
{       
int i;
for (i = 0; i <dataBuffer.count; i++)
dataBuffer.buffer[i] = dataBuffer.buffer[i+1];
}
void push(int data)      //产品送入缓冲区
{           
dataBuffer.buffer[dataBuffer.count++] = data;
}
int pop()            //从缓冲区取出产品
{                       
int data = dataBuffer.buffer[0];
dataBuffer.count--;           
moveDataForward();
return data;
}
void initProcess() {            //初始化进程集合
int i;
char digitTemp[5];
srand(time(NULL));
for (i = 0; i <processNum; i++) {
process[i].roleFlag = rand()%2;            // 随机指定当前进程为生产者或消费者
if (process[i].roleFlag)
strcpy(process[i].name, "生产者");
else
strcpy(process[i].name, "消费者");
strcat(process[i].name, itoa(i+1, digitTemp, 10));
process[i].currentState = 1;
process[i].currentStep = 1;
process[i].code = i + 1;
producerCongestionQueue[i] = 0;
consumerCongestionQueue[i] = 0;
shareCongestionQueue[i] = 0;
}
}
void wakeup(int *pcq) {                    //唤醒进程
int code = pcq[0] - 1;                //取出队首进程
process[code].currentState = 1;        //进程置为就绪态
//当进程被唤醒后继续执行任务
if (process[code].roleFlag == 1) {        //生产者
if (process[code].currentStep == 2) {
printf("%20s: 该进程被唤醒!申请空缓冲区成功!\n", process[code].name);
} else if (process[code].currentStep == 3) {
printf("%20s: 该进程被唤醒!申请访问缓冲区成功!\n", process[code].name);
}
} else if (process[code].roleFlag == 0) {    //消费者
if (process[code].currentStep == 1) {
process[code].data = pop();
printf("%20s: 该进程被唤醒!申请取产品%d成功!\n", process[code].name, process[code].data);
} else if (process[code].currentStep == 2) {
printf("%20s: 该进程被唤醒!申请访问缓冲区成功!\n", process[code].name);
}       
}
process[code].currentStep++;
for (int i = 1; (i <processNum) && (pcq[i] != 0); i++) {        //删除队首进程
pcq[i-1] = pcq[i];
if (pcq[i-1] >processNum) {
pcq[i-1] = 0;
}
}  
}
void sleep(int pcq[], int code) {            //阻塞进程   
int i;
process[code-1].currentState = 0;            //进程置为阻塞态
for (i = 0; i <processNum; i++) {
if (!pcq[i]) {
pcq[i] = code;
break;
}
}
}
void P(Seamphore *s, Process *p) {                //模拟P操作
s->value -= 1;
if (s->value>= 0) {                       
if (p->roleFlag == 1) {                    //生产者
if (p->currentStep == 2) {
printf("%20s: 申请空缓冲区成功!\n", p->name);
} else if (p->currentStep == 3) {
printf("%20s: 申请访问缓冲区成功!\n", p->name);
}
} else if (p->roleFlag == 0) {            //消费者
if (p->currentStep == 1) {
printf("%20s: 申请取出产品成功!\n", p->name);
} else if (p->currentStep == 2) {
printf("%20s: 申请访问缓冲区成功!\n", p->name);
}
}       
p->currentStep++;                        //下一步
} else if (s->value < 0) {               
if (p->roleFlag == 1) {                    //生产者
if (p->currentStep == 2) {
printf("%20s: 无空缓冲区, 该进程被阻塞!\n", p->name);
} else if (p->currentStep == 3) {
printf("%20s: 其他进程正在访问缓冲区, 该进程被阻塞!\n", p->name);
}
} else if (p->roleFlag == 0) {            //消费者
if (p->currentStep == 1) {
printf("%20s: 无产品可取, 该进程被阻塞!\n", p->name);
} else if (p->currentStep == 2) {
printf("%20s: 其他进程正在访问缓冲区, 该进程被阻塞!\n", p->name);
}
}
sleep(s->pcq, p->code);        //阻塞进程       
}
}
void V(Seamphore *s, Process *p) {            //模拟V操作
s->value += 1;
if (p->roleFlag == 1) {                    //生产者
if (p->currentStep == 5) {
printf("%20s: 释放缓冲区访问权!\n", p->name);
} else if (p->currentStep == 6) {
printf("%20s: 产品已送入缓冲区，产品数量增加!\n", p->name);
}
} else if (p->roleFlag == 0) {            //消费者
if (p->currentStep == 4) {
printf("%20s: 释放缓冲区访问权!\n", p->name);
} else if (p->currentStep == 5) {
printf("%20s: 产品已取出，空缓冲区数量增加!\n", p->name);
}
}
if (s->value<= 0) {
wakeup(s->pcq);       
}
p->currentStep++;           
}
void produce(Process *p) {            //模拟生产者进程
switch (p->currentStep) {
case 1:                                                            //1 生产产品
p->data = rand()%1000;
printf("%20s: 生产一个产品%d!\n", p->name, p->data);
p->currentStep++;
break;
case 2:                                                            //2 申请空缓冲区
P(&empty, p);
break;
case 3:                                                            //3 申请访问缓冲区
P(&mutex, p);
break;
case 4:                                                            //4 将产品送入缓冲区
push(p->data);
printf("%20s: 将产品%d正送入缓冲区!\n", p->name, p->data);
p->currentStep++;
break;
case 5:                                                            //5 释放缓冲区访问权
V(&mutex, p);
break;
case 6:                                                            //6 产品已送入缓冲区，产品数量加1
V(&full, p);
p->currentStep = 1;
break;
}
}
void consume(Process *p) {                //模拟消费者进程
switch (p->currentStep) {
case 1:                                                            //1 申请从缓冲区取出产品
P(&full, p);
break;
case 2:                                                            //2 申请访问缓冲区
P(&mutex, p);
break;
case 3:                                                            //3 从缓冲区中取出产品
p->data = pop();
printf("%20s: 从缓冲区中正取出产品%d!\n", p->name, p->data);
p->currentStep++;
break;
case 4:                                                            //4 释放缓冲区访问权
V(&mutex, p);
break;
case 5:                                                    //5 已从缓冲区取出一个产品，空缓冲区数量加1
V(&empty, p);
break;
case 6:                                                            //6 消费产品
printf("%20s: 消费产品%d!\n", p->name, p->data);
p->currentStep = 1;
break;
}
}
void rr() {            //模拟进程调度
Process *p;
while(1) {
p = &process[rand()%processNum];        //随机选取进程集合内某一进程
if (!p->currentState) {                    //选取的进程若为阻塞态，重新选取其它可执行进程
continue;
}
if (p->roleFlag) {            //1: 生产者  0: 消费者
produce(p);
} else {
consume(p);
}   
Sleep(100);
}
}
void deal() {
printf("\t\t生产者消费者算法模拟\n\n");
initProcess();
rr();
}
int main () {
deal();
return 0;
}
GodOuO
关注
专栏目录
C语言实现生产者消费者问题
05-27
C语言实现生产者消费者问题，分配具有n个缓冲区的缓冲池，作为共享资源。 定义两个资源型信号量empty 和full，empty信号量表示当前空的缓冲区数量，full表示当前满的缓冲区数量。 定义互斥信号量mutex，当某个进程访问缓冲区之前先获取此信号量，在对缓冲区的操作完成后再释放此互斥信号量。以此实现多个进程对共享资源的互斥访问。 创建3进程（或者线程）作为生产者，4个进程（或者线程）作为消费者。创建一个文件作为数据源，文件中事先写入一些内容作为内容。 编写代码实现生产者进程的工作内容，即从文件中读取数据，然后申请一个empty信号量，和互斥信号量，然后进入临界区操作将读取的数据放入此缓冲区中。并释放empty信号量和互斥信号量。
C语言实战——生产者消费者问题
qq_39079631的博客
06-06 9481
C语言实战——生产者消费者问题 方法摘要 生产者消费者共享缓冲区，生产者向缓冲区中放数据，消费者从缓冲取中取数据，当缓冲区中被放满时，生产者进程就必须进入挂起状态，直到消费者从缓冲中取走数据时，生产者才能继续向缓冲区中存放数据，同样当缓冲取中没有数据时，消费者进程就必须进入挂起休眠状态，直到生产者向缓冲区中放入数据时，消费者才能被唤醒继续从缓冲区中取走数据。 简写代码 对于生产者： void producer(void) { int item; while(1) { item = produc
Linux多线程编程-生产者与消费者模型详解与实现（C语言）
最新发布
qq_42037383的博客
07-14 593
生产者-消费者模型是并发编程中的经典问题，描述了多个线程（或进程）如何安全、有效地共享有限的缓冲区资源。：负责生成数据或者将数据放置到共享缓冲区中。：负责从共享缓冲区中取出数据并进行处理或消费。
操作系统-生产者与消费者问题的C语言实现
03-06
1．模拟用信号量机制实现生产者和消费者问题。 2．设计报告内容应说明： ⑴ 课程设计目的与功能； ⑵ 需求分析，数据结构或模块说明(功能与框图)； ⑶ 源程序的主要部分； ⑷ 运行结果与运行情况分析； ⑸ 自我评价与总结：
C语言 生产者消费者问题
qq_45740212的博客
01-29 3790
本文介绍并实现了生产者消费者经典进程同步问题
C例子：生产者与消费者问题
01-17
该程序是我写的博客“一起talk C栗子吧（第一百零六回：C语言实例--生产者与消费者问题二）”的配套程序，共享给大家使用
Linux环境下C语言实现生产者消费者问题的代码
03-11
在Linux下完整C语言实现生产者消费者问题的代码。其中涉及信号量、多线程、GCC编译、PV操作等基础知识。Linux下通过gcc - o yy xxx.c -pthread，再通过./yy即可运行。
操作系统实验二 ——生产者消费者问题
04-10
操作系统实验二——生产者消费者问题是计算机科学中一个经典的问题，主要涉及进程同步和资源管理。在多线程或并发编程的环境中，生产者消费者模型是一个常见的设计模式，用于解决数据处理流程中的同步问题。在这个...
使用c语言编程实现经典的进程同步问题——生产者消费者问题的模拟；
04-18
在C语言中，可以使用互斥锁和条件变量来实现生产者消费者问题的模拟。生产者和消费者都需要遵循一定的流程，如下所示： 生产者： 1.检查缓冲区是否已满，如果已满则等待。 2.获取互斥锁。 3.生产数据放入缓冲区。 4...
生产者——消费者 c语言
11-27
为了在多线程环境下正确实现生产者-消费者问题，可以使用以下C语言库提供的工具： 1. **pthread库**：提供线程创建和同步原语，如`pthread_create`、`pthread_mutex_lock`、`pthread_mutex_unlock`和`pthread_cond_...
操作系统实验——进程的同步与互斥（读者写者问题）
03-21
以生产者消费者模型为基础，在Windows环境下创建一个控制台进程，在该进程中创建读者写者线程模拟生产者和消费者。写者线程写入数据，然后将数据放置在一个空缓冲区中供读者线程读取。读者线程从缓冲区中获得数据，...
C语言实现操作系统中生产者消费者
06-26
用C-Free5软件写的，主函数为Int类型。在其他软件上可能要改成void，算法方面没有什么问题。如果要缓冲池满就把生产者M1的数改的比消费者M2的高，要缓冲池空则相反。
Linux c语言多线程实现生产者/消费者问题
03-13
以生产者/消费者问题为例来阐述Linux线程的控制和通信。一组生产者线程与一组消费者线程通过缓冲区发生联系。生产者线程将生产的产品送入缓冲区，消费者线程则从中取出产品。缓冲区有N 个，是一个环形的缓冲池。 使用命令cc consumer.c -o consumer编译
用C语言模拟生产者消费者问题
07-27
用C语言模拟进程通信的生产者消费者问题，包括windows和linux版本
生产者与消费者问题（C语言 超详细全）小白可入
Zjyzzy123456789的博客
11-05 7381
【代码】生产者与消费者问题（详细全）
生产者-消费者问题实现 (linux下C语言)
ruixj的专栏
11-30 4383
操作系统的一个经典问题是"生产者-消费者"问题, 这涉及同步信号量和互斥信号量的应用, 在这里,我用线程的同步和互斥来实现. #include #include #include #include #include #define N 2   // 消费者或者生产者的数目#define M 10 // 缓冲数目int
生产者消费者问题c语言_C中的生产者消费者问题
culing2941的博客
09-14 5114
生产者消费者问题c语言Here you will learn about producer consumer problem in C. 在这里，您将了解C语言中的生产者消费者问题。 Producer consumer problem is also known as bounded buffer problem. In this problem we have two processes, ...
用c语言实现“生产者和消费者”问题
weixin_52451652的博客
04-18 8168
实验要求：要求程序运行时，按任意键停止，显示各种信息 #include <stdio.h> #include<stdlib.h> #include<time.h> int mutex=1; int empty=10; int full=0; int buf[10]; int front=0,rear=0; int i; //p操作 .申请 void p(int *x) { *x=(*x)-1; } //v操作 .释放 void v(int *x) { *x=
C语言：生产者-消费者问题、读者-写者问题
linwh8的博客
06-19 7867
1.生产者-消费者问题：题目要求 • 在 6.6.1 小节中，使用了三个信号量: empty (以记录有多少空位)、full (以记录有多少满位)以及 mutex (二进制信号量或互斥信号量，以保 护对缓冲插入与删除的操作)。对于本项目， empty 与 full 将采用标 准计数信号量，而 mutex 将采用二进制信号量。生产者与消费者作 为独立线程，在 empty、full、mut
生产者——消费者问题算法C语言代码
05-18
下面是一个简单的生产者-消费者问题的C语言代码实现： ```c #include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <unistd.h> #define BUFFER_SIZE 10 int buffer[BUFFER_SIZE]; // 缓冲区数组 int counter = 0; // 缓冲区计数器 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; // 互斥锁 pthread_cond_t full = PTHREAD_COND_INITIALIZER; // 缓冲区满条件变量 pthread_cond_t empty = PTHREAD_COND_INITIALIZER; // 缓冲区空条件变量 void *producer(void *arg) { int val; while (1) { val = rand() % 100; // 随机生成数值 pthread_mutex_lock(&mutex); while (counter == BUFFER_SIZE) // 缓冲区满，等待空闲空间 pthread_cond_wait(&empty, &mutex); buffer[counter++] = val; // 放入缓冲区 printf("生产者：%d，缓冲区大小：%d\n", val, counter); pthread_mutex_unlock(&mutex); pthread_cond_signal(&full); // 发送缓冲区满信号 sleep(1); } return NULL; } void *consumer(void *arg) { int val; while (1) { pthread_mutex_lock(&mutex); while (counter == 0) // 缓冲区空，等待生产者 pthread_cond_wait(&full, &mutex); val = buffer[--counter]; // 从缓冲区取出 printf("消费者：%d，缓冲区大小：%d\n", val, counter); pthread_mutex_unlock(&mutex); pthread_cond_signal(&empty); // 发送缓冲区空信号 sleep(1); } return NULL; } int main(int argc, char *argv[]) { pthread_t tid1, tid2; srand(time(NULL)); pthread_create(&tid1, NULL, producer, NULL); pthread_create(&tid2, NULL, consumer, NULL); pthread_join(tid1, NULL); pthread_join(tid2, NULL); return 0; } ``` 在上面的代码中，使用了互斥锁和条件变量来实现线程同步。生产者线程和消费者线程分别使用互斥锁来保护共享变量（缓冲区计数器和缓冲区数组），并使用条件变量来等待对方的信号。当生产者向缓冲区放入数据时，如果缓冲区已满，则会等待消费者取走数据后再放入；当消费者从缓冲区取出数据时，如果缓冲区已空，则会等待生产者放入数据后再取出。这样就保证了生产者和消费者之间的同步和互斥。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值