问哪个大佬给我讲解一下？

#define _CRT_SECURE_NO_WARNINGS 1

/*

* 多道程序设计模拟

* 作者：hjz

* 时间：2020/11/8

*

* 本次为操作系统的实验，模拟了A,B,C三个程序的多道程序的执行,比较顺序执行和多道程序设计

* 程序执行的顺序为：计算->IO操作->计算->结束，分为三段

* 例如：

* A先计算30ms，再io操作40ms，再计算10ms。

* B先计算60ms，再io操作30ms，再计算10ms。

* A先计算20ms，再io操作40ms，再计算20ms。

*

* 本次实验只模拟了三个程序和单通道模式

*/

#include<stdio.h>

#include<stdlib.h>

#define true 1

#define false 0

#define CPU 2

#define IO -1

typedef struct {

char id;//任务名称

int cpu_time1;//第一次计算时间

int cpu_time2;//第二次计算时间

int io_time;//io操作时间

short flag;//第一次是否已计算完，计算完为1

}pro;//程序结构体

typedef struct {

pro* arr[3];//队列

int first;//队头

int last;//队尾

int n;//元素数量

}queue;//队列

queue cpu_q;//cpu队列

queue io_q;//io队列

void init(pro*, pro*, pro*);

void input(pro*);

void run_seq();

void run_par();

int enqueue(pro*, int);

pro* dequeue(int);

int empty(int);

int full(int);

int back(int, pro*);

int main() {

pro* pro_a = 0;

pro* pro_b = 0;

pro* pro_c = 0;

init(pro_a, pro_b, pro_c);

run_seq();

run_par();

return 0;

}

/*

* 判定队列是否是空

*

* 参数：

* i:为1判定cpu队列，否则为io队列

* 返回值：如果为空返回正数，否则返回0

*/

int empty(int i) {

if (i == CPU) {

return cpu_q.n == 0;

}

else {

return io_q.n == 0;

}

}

/*

* 判定队列是否满

*

* 参数：

* i:为CPU判定cpu队列，否则为io队列

* 返回值：如果满返回正数，否则返回0

*/

int full(int i) {

if (i == CPU) {

return cpu_q.n == 3;

}

else {

return io_q.n == 3;

}

}

/*

* 入队操作

*

* 参数：

* p:要入队的程序

* i:为CPU入cpu队列，否则为io队列

* 返回值：如果正常入队返回1，否则返回0

*/

int enqueue(pro* p, int i) {

if (full(i)) return false;

if (i == CPU) {

cpu_q.arr[cpu_q.last] = p;

cpu_q.last = (cpu_q.last + 1) % 3;

cpu_q.n++;

}

else {

io_q.arr[io_q.last] = p;

io_q.last = (io_q.last + 1) % 3;

io_q.n++;

}

return true;

}

/*

* 出队操作

*

* 参数：

* i:为1出cpu队列，否则为io队列

* 返回值：返回队头元素或NULL

*/

pro* dequeue(int i) {

if (empty(i)) return NULL;

pro* temp;

if (i == CPU) {

temp = cpu_q.arr[cpu_q.first];

cpu_q.arr[cpu_q.first] = NULL;

cpu_q.first = (cpu_q.first + 1) % 3;

cpu_q.n--;

}

else {

temp = io_q.arr[io_q.first];

io_q.arr[io_q.first] = NULL;

io_q.first = (io_q.first + 1) % 3;

io_q.n--;

}

return temp;

}

/*

* 将元素添加到队列头

*

* 参数：

* i:为CPU则添加到cpu队列，否则添加到io队列

* p:要添加的任务

* 返回值：添加成功返回1

*/

int back(int i, pro* p) {

if (full(i)) return false;

if (i == CPU) {

cpu_q.first = (cpu_q.first - 1) % 3;

cpu_q.arr[cpu_q.first] = p;

cpu_q.n++;

return true;

}

else {

io_q.first = (io_q.first - 1) % 3;

io_q.arr[io_q.first] = p;

io_q.n++;

return true;

}

return false;

}

/*

* 程序计算时间和io时间初始化

*

* 参数：

* p:要被初始化的程序

*/

void input(pro* p) {

printf("请输入程序%c第一次计算的时间：", p->id);

scanf("%d", &(p->cpu_time1));

printf("请输入程序%c所需要的io时间：", p->id);

scanf("%d", &(p->io_time));

printf("请输入程序%c第二次计算的时间：", p->id);

scanf("%d", &(p->cpu_time2));

p->flag = 0;

putchar('\n');

}

/*

* 队列和多道程序初始化

*

* 参数：

* a:被初始化程序1

* b:被初始化程序2

* c:被初始化程序3

*/

void init(pro* a, pro* b, pro* c) {

printf("---------程序初始化---------\n");

a = (pro*)malloc(sizeof(pro));

b = (pro*)malloc(sizeof(pro));//动态分配内存

c = (pro*)malloc(sizeof(pro));

a->id = 'A';

b->id = 'B';

c->id = 'C';

input(a);

input(b);

input(c);

cpu_q.arr[0] = a;

cpu_q.arr[1] = b;

cpu_q.arr[2] = c;

cpu_q.first = 0;

cpu_q.last = 0;

cpu_q.n = 3;

io_q.first = 0;

io_q.last = 0;

io_q.n = 0;

}

/*

* 顺序执行模式

*/

void run_seq() {

printf("---------顺序执行模式---------\n");

int i, sum = 0;

for (i = 0; i < 3; i++) {

printf("程序%c计算%dms,io%dms,计算%dms\n",

cpu_q.arr[i]->id, cpu_q.arr[i]->cpu_time1, cpu_q.arr[i]->io_time, cpu_q.arr[i]->cpu_time2);

sum = sum + cpu_q.arr[i]->cpu_time1 + cpu_q.arr[i]->io_time + cpu_q.arr[i]->cpu_time2;

}

putchar('\n');

printf("总耗时%dms\n", sum);

}

/*

* 多道执行模式

*/

void run_par() {

printf("---------多道程序模式---------\n");

pro* temp, * temp1;

int time, sum = 0;

while (!empty(CPU) || !empty(IO)) {

//如果io队列为空，则进行计算

if (empty(IO)) {

temp = dequeue(CPU);

if (temp != NULL) {

time = (temp->flag == 0) ? (temp->cpu_time1) : (temp->cpu_time2);

printf("程序%c计算%dms\n", temp->id, time);

sum += time;

if (temp->flag == 0) {//如果是第一次计算，放入io队列，否则该程序结束

temp->flag = 1;

enqueue(temp, IO);

}

else free(temp);

continue;

}

exit(0);

}

//如果cpu队列为空，则进行io调度，io调度完成后继续完成计算至程序结束

if (empty(CPU)) {

temp = dequeue(IO);

if (temp != NULL) {

printf("程序%c进行io%dms\n", temp->id, temp->io_time);

printf("程序%c计算%dms\n", temp->id, temp->cpu_time2);

sum = sum + temp->io_time + temp->cpu_time2;

free(temp);

continue;

}

exit(0);

}

//如果io队列和cpu队列都不为空，则io操作和计算同时进行

temp = dequeue(CPU);

temp1 = dequeue(IO);

if (temp->flag == 0) time = temp->cpu_time1 - temp1->io_time;

else time = temp->cpu_time2 - temp1->io_time;

if (time >= 0) {

if (temp->flag == 0) {

printf("程序%c计算%dms的同时，程序%c进行io%dms", temp->id, temp->cpu_time1, temp1->id, temp1->io_time);

sum += temp->cpu_time1;

}

else {

printf("程序%c计算%dms的同时，程序%c进行io%dms", temp->id, temp->cpu_time2, temp1->id, temp1->io_time);

sum += temp->cpu_time2;

}

while (time > 0) {//如果在io操作完成后，正在计算的程序还没完成计算，继续调度io队列中的下一个

int temp_time;

if (!empty(IO)) {

pro* temp2 = dequeue(IO);

temp_time = temp2->io_time;

if (temp_time > time) {//如果下一个io操作所需的时间过长，则先进行一段io操作，再放回队首，下次再调度

printf(",程序%c进行io%dms", temp2->id, time);

temp2->io_time = temp2->io_time - time;

back(IO, temp2);

break;

}

else {

printf(",程序%c进行io%dms", temp2->id, temp_time);

time -= temp_time;

enqueue(temp2, CPU);

}

}

break;

}

enqueue(temp1, CPU);

if (temp->flag == 0) {

temp->flag = 1;

enqueue(temp, IO);//如果是第一次计算，则进入io队列

}

else free(temp);

putchar('\n');

}

else {

sum += temp1->io_time;

if (temp->flag == 0) {

printf("程序%c计算%dms的同时，程序%c进行io%dms", temp->id, temp->cpu_time1, temp1->id, temp1->io_time);

}

else {

printf("程序%c计算%dms的同时，程序%c进行io%dms", temp->id, temp->cpu_time2, temp1->id, temp1->io_time);

}

time = -time;

while (time > 0) {//如果计算完成后，io操作还在继续，则继续调度cpu队列

int temp_time;

if (!empty(CPU)) {

pro* temp2 = dequeue(CPU);

temp_time = (temp2->flag == 0) ? (temp2->cpu_time1) : (temp2->cpu_time2);

if (temp_time > time) {

printf(",程序%c计算%dms\n", temp2->id, time);

if (temp2->flag == 0) temp2->cpu_time1 = temp2->cpu_time1 - time;

else temp2->cpu_time2 = temp2->cpu_time2 - time;

back(CPU, temp2);

break;

}

else {

printf(",程序%c计算%dms", temp2->id, temp_time);

time -= temp_time;

if (temp2->flag == 0) {

temp2->flag = 1;

enqueue(temp2, CPU);

}

else free(temp2);

}

}

break;

}

enqueue(temp1, CPU);//完成io操作后调入cpu队列

if (temp->flag == 0) {

temp->flag = 1;

enqueue(temp, IO);

}

else free(temp);

putchar('\n');

}

}

printf("总耗时%dms\n", sum);

}