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

百度文献查看原文

核心代码：

#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;
}

C语言——生产者消费者问题相关推荐

C语言生产者消费者实验报告,生产者与消费者实验报告.doc
生产者与消费者实验报告.doc 生产者和消费者实验报告[实验目的]1. 加深对进程概念的理解,明确进程和程序的区别.2. 进一步认识并发执行的实质.3. 验证用信号量机制实现进程互斥的方法.4. 验证 ...
windows进程生产者消费者代码c语言,生产者消费者问题---C语言实现
生产者消费者问题(Producer-consumer problem) 是一个多线程同步问题的经典案例. 生产者的主要作用是生成一定量的数据放到缓冲区中,然后重复此过程.与此同时,消费者也在缓冲区消耗 ...
C语言生产者消费者模型
友链互斥量mutex 条件变量cond gcc 1.c -o 1 -lpthread // ..使用内存映射可以拷贝文件 /* 对原始文件进行内存映射创建一个新文件把新文件的数据拷贝映射到内存中 ...
实现一个通用的生产者消费者队列（c语言版本）
背景:笔者之前一直从事嵌入式音视频相关的开发工作,对于音视频的数据的处理,生产者消费者队列必不可少,而如何实现一个高效稳定的生产者消费者队列则十分重要,不过按照笔者从业的经验,所看到的现象,不容乐观, ...
生产者消费者操作系统实验报告用C语言来实现
#include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <unistd.h& ...
C语言实战——生产者消费者问题
C语言实战--生产者消费者问题方法摘要生产者消费者共享缓冲区,生产者向缓冲区中放数据,消费者从缓冲取中取数据,当缓冲区中被放满时,生产者进程就必须进入挂起状态,直到消费者从缓冲中取走数据时,生产者 ...
Linux下生产者消费者问题的C语言实现
注:查看全文请关注作者,或点击前往:生产者-消费者问题的C语言实现实验六生产者-消费者问题实现实验题目要求在Linux操作系统下用C实现经典同步问题:生产者-消费者,具体要求如下: (1) ...
在Linux系统下生产者消费者,生产者-消费者问题实现 (linux下C语言)
操作系统的一个经典问题是"生产者-消费者"问题, 这涉及同步信号量和互斥信号量的应用, 在这里,我用线程的同步和互斥来实现. /* * author 张文 * 2008/06/20 ...
生产者消费者代码c语言_由生产者消费者模型引出的线程同步问题
由生产者消费者模型引出的线程同步问题基本生产者消费者模型: 代码示例: 数据模型: /*** Created by IntelliJ IDEA.** @Author: ZhangDong* @Dat ...

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

C语言——生产者消费者问题相关推荐

最新文章

热门文章