基于反馈(Feed Back,FB)排队算法的CPU调度的模拟实现资料
进程调度模拟算法

进程调度模拟算法进程调度是操作系统中的重要组成部分之一,它负责决定在多道程序环境下,哪个进程将获得CPU的使用权。
进程调度模拟算法是为了研究和评估不同调度策略的性能而开发的一种仿真方法。
在实际系统中,调度算法会受到多种因素的影响,如进程优先级、进程的I/O需求、进程的实际执行时间等。
通过模拟这些因素,可以更好地理解不同调度算法之间的差异,并选择最合适的算法来满足特定需求。
下面介绍两种常见的进程调度模拟算法:先来先服务(FCFS)和最短作业优先(SJF)算法。
1. 先来先服务(FCFS)算法:该算法按照进程到达的顺序来调度任务。
当一个进程完成或阻塞时,下一个已到达的进程将获得CPU的使用权。
这种算法非常简单,但是不适用于长作业时间和短作业时间交替出现的情况。
在短作业启动时,长作业仍然在运行,使得短作业的等待时间增加。
2. 最短作业优先(SJF)算法:该算法根据任务的执行时间来调度进程。
在该算法中,每个进程的执行时间都是已知的,并且操作系统根据已知的执行时间来决定哪个进程获得CPU的使用权。
在短作业优先算法中,短作业将会先被调度,这样有助于减少平均周转时间和等待时间。
但是,短作业优先算法容易产生“饥饿”现象,即长作业可能会一直等待,而短作业一直得到CPU的使用权。
除了以上两种算法,还有其他的进程调度模拟算法。
例如:- 时间片轮转(RR)调度算法:使用固定的时间片来调度进程,当时间片用完后,该进程被放入就绪队列的末尾。
- 优先级调度算法:每个进程都拥有一个优先级,优先级越高的进程越早被调度。
这种方法可以根据不同进程的紧迫程度和重要性来进行调度。
- 多级反馈队列调度算法:将就绪队列划分为多个队列,并根据进程的性质和优先级将进程放入不同的队列。
每个队列都有不同的优先级和时间片大小,进程可以通过提高优先级或时间片大小来提高被调度的机会。
在实际应用中,需要根据系统需求和性能指标选择合适的调度算法。
常用的性能指标包括平均周转时间、平均等待时间、CPU利用率等。
多级反馈算法 -回复

多级反馈算法-回复多级反馈算法(Multi-level Feedback Queue Scheduling Algorithm)是一种常用的调度算法,主要应用于操作系统中的进程调度。
该算法的核心思想是根据进程的行为特征和优先级将进程分配到不同的队列中,并根据每个队列的特点进行合理的调度。
在传统的操作系统中,通常使用先来先服务(FCFS)或者优先级调度算法。
然而,这些算法存在一些问题。
比如,FCFS无法充分利用系统资源,造成长作业的等待时间过长;而优先级调度算法又可能导致低优先级进程永远得不到调度。
为了更好地解决这些问题,多级反馈算法应运而生。
首先,我们来了解一下多级反馈算法的基本原理。
该算法将进程分成多个队列,并为每个队列分配不同的时间片大小。
一般来说,最高优先级的队列时间片最小,而最低优先级的队列时间片最大。
当一个进程进入系统时,首先被分配到最高优先级的队列中。
如果该进程在时间片结束前完成,那么它就会被移出队列,否则它将被移到下一个优先级更低的队列中。
这样,高优先级的队列会得到更多的CPU时间,从而提高整体系统的执行效率。
接下来,我们详细解析多级反馈算法的具体流程。
首先,系统会为每个队列分配一个时间片大小,一般而言,高优先级队列的时间片相对较小,低优先级队列的时间片较大。
当一个进程进入系统时,它会被放置在最高优先级队列,并被分配时间片。
如果该进程在时间片耗尽前完成,它会被移出队列,并不再分配时间片。
如果该进程在时间片结束前未能完成,它会被移到下一个优先级更低的队列中,并继续等待。
这样,每个队列都有机会被调度执行,从而提高系统资源利用率。
在实际应用中,多级反馈算法还可以根据进程的行为特征进行动态调整。
比如,对于经常I/O阻塞的进程,可以将其移至低优先级队列,以避免占用过多的CPU时间。
而对于经常计算密集型的进程,可以将其移至高优先级队列,以提高其执行效率。
这种根据进程行为特征的动态调整,可以进一步提升系统的性能和响应速度。
操作系统进程调度算法模拟实验报告

操作系统进程调度算法模拟实验报告一、实验目的本实验旨在深入理解操作系统的进程调度算法,并通过模拟实验来探究不同调度算法之间的差异和优劣。
二、实验原理操作系统的进程调度算法是决定进程执行顺序的重要依据。
常见的调度算法有先来先服务(FCFS)、最短作业优先(SJF)、优先级调度(Priority Scheduling)、轮转法(Round Robin)和多级反馈队列调度(Multilevel Feedback Queue Scheduling)等。
1.先来先服务(FCFS)算法:按照进程到达的先后顺序进行调度,被调度的进程一直执行直到结束或主动阻塞。
2.最短作业优先(SJF)算法:按照进程需要的执行时间的短长程度进行调度,执行时间越短的进程越优先被调度。
3. 优先级调度(Priority Scheduling)算法:为每个进程分配一个优先级,按照优先级从高到低进行调度。
4. 轮转法(Round Robin)算法:将进程按照到达顺序排列成一个队列,每个进程被分配一个时间片(时间量度),当时间片结束时,将进程从队列头取出放置到队列尾。
5.多级反馈队列调度算法:将进程队列分为多个优先级队列,每个队列时间片大小依次递减。
当一个队列中的进程全部执行完毕或者发生阻塞时,将其转移到下一个优先级队列。
三、实验步骤与结果1.实验环境:- 操作系统:Windows 10- 编译器:gcc2.实验过程:(1)首先,设计一组测试数据,包括进程到达时间、需要的执行时间和优先级等参数。
(2)根据不同的调度算法编写相应的调度函数,实现对测试数据的调度操作。
(3)通过模拟实验,观察不同调度算法之间的区别,比较平均等待时间、完成时间和响应时间的差异。
(4)将实验过程和结果进行记录整理,撰写实验报告。
3.实验结果:这里列举了一组测试数据和不同调度算法的结果,以便对比分析:进程,到达时间,执行时间,优先------,----------,----------,-------P1,0,10,P2,1,1,P3,2,2,P4,3,1,P5,4,5,a.先来先服务(FCFS)算法:平均等待时间:3.8完成时间:15b.最短作业优先(SJF)算法:平均等待时间:1.6完成时间:11c. 优先级调度(Priority Scheduling)算法:平均等待时间:2.8完成时间:14d. 轮转法(Round Robin)算法:时间片大小:2平均等待时间:4.8完成时间:17e.多级反馈队列调度算法:第一级队列时间片大小:2第二级队列时间片大小:4平均等待时间:3.8完成时间:17四、实验总结通过上述的实验结果可以得出以下结论:1.在上述测试数据中,最短作业优先(SJF)算法的平均等待时间最短,说明该算法在短作业的情况下能够有效地减少等待时间。
进程调度实验报告

进程调度实验报告一、实验目的。
本实验旨在通过对进程调度算法的模拟和实验,加深学生对进程调度原理的理解,掌握各种进程调度算法的特点和应用场景,提高学生的实际操作能力和分析问题的能力。
二、实验环境。
本次实验使用了C语言编程语言,通过模拟实现了先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)和多级反馈队列(MFQ)四种进程调度算法。
三、实验过程。
1. 先来先服务(FCFS)调度算法。
先来先服务调度算法是一种非抢占式的调度算法,按照进程到达的先后顺序进行调度。
在本次实验中,我们通过模拟多个进程到达并排队等待CPU执行,观察其平均等待时间和平均周转时间。
实验结果表明,先来先服务调度算法适用于作业长度差异较大的情况,但容易产生“饥饿”现象。
2. 最短作业优先(SJF)调度算法。
最短作业优先调度算法是一种非抢占式的调度算法,按照作业执行时间的长短进行调度。
在本次实验中,我们通过模拟多个作业的执行时间,观察其平均等待时间和平均周转时间。
实验结果表明,最短作业优先调度算法能够最大程度地减少平均等待时间,但可能会导致长作业被“饿死”。
3. 时间片轮转(RR)调度算法。
时间片轮转调度算法是一种抢占式的调度算法,每个进程被分配一个时间片,当时间片用完后,该进程被放到队尾等待。
在本次实验中,我们通过模拟多个进程的执行和时间片的调度,观察其平均等待时间和平均周转时间。
实验结果表明,时间片轮转调度算法能够保证每个进程都能得到一定的执行时间,但可能会导致上下文切换频繁。
4. 多级反馈队列(MFQ)调度算法。
多级反馈队列调度算法是一种综合性的调度算法,根据进程的优先级和执行时间进行动态调整。
在本次实验中,我们通过模拟多个进程的执行和不同优先级队列的调度,观察其平均等待时间和平均周转时间。
实验结果表明,多级反馈队列调度算法能够兼顾短作业和长作业,提高了系统的整体性能。
四、实验总结。
通过本次实验,我们深入理解了不同进程调度算法的特点和适用场景。
多级反馈队列调度算法的原理

多级反馈队列调度算法的原理1.多级反馈队列调度算法是一种常见的进程调度算法,旨在平衡系统的吞吐量、响应时间和公平性。
它采用多个队列,每个队列有不同的优先级,进程根据其行为在这些队列之间移动。
本文将详细介绍多级反馈队列调度算法的原理和工作方式。
2. 算法概述多级反馈队列调度算法的核心思想是通过不同优先级的队列来对进程进行调度。
每个队列有不同的时间片大小,高优先级队列的时间片较小,低优先级队列的时间片较大。
当一个进程在当前队列中运行完时间片,它将被移动到下一优先级的队列。
如果一个进程在某个队列运行完时间片后还没有执行完,它将继续在当前队列等待,以便有更多的机会执行。
3. 多级队列结构典型的多级反馈队列调度算法包括多个队列,通常包括三个或更多级别。
每个队列的优先级不同,如高、中、低。
时间片大小逐渐增大,高优先级队列的时间片小于中优先级,中优先级小于低优先级。
4. 调度过程4.1 进程到达当一个新进程到达系统时,它被分配到最高优先级队列。
4.2 运行和时间片耗尽进程在当前队列中运行,如果它的时间片耗尽,它将被移动到下一优先级的队列。
如果进程在当前队列没有完成执行,它将在下一次调度时继续运行。
4.3 优先级提升如果一个进程在低优先级队列等待了很长时间,系统可能会将其提升到高优先级队列,以确保长时间等待的进程有机会获得更多的CPU 时间。
5. 优点5.1 响应时间短由于高优先级队列的时间片较小,进程在高优先级队列中能够更快地执行,因此系统的响应时间相对较短。
5.2 吞吐量高对于短时间运行的进程,能够快速地在高优先级队列中完成执行,有助于提高系统的吞吐量。
5.3 公平性低优先级队列的时间片较大,长时间运行的进程有足够的机会在低优先级队列中执行,增加了系统的公平性。
6. 缺点6.1 管理复杂性多级反馈队列调度算法需要维护多个队列,涉及到队列的调度和进程的迁移,因此管理和实现相对复杂。
6.2 死锁可能如果系统中的进程都是长时间运行的,并且高优先级队列的时间片较小,可能导致低优先级队列中的进程长时间等待,进而引发死锁问题。
操作系统进程调度算法模拟实验

操作系统进程调度算法模拟实验进程调度是操作系统中一个重要的功能,它决定了哪些进程能够获得处理器资源以及如何按照一定的策略来分配这些资源。
为了更好地理解进程调度算法的工作原理,我们可以进行一个模拟实验来观察不同算法的表现效果。
实验设想:我们设想有5个进程要运行在一个单核处理器上,每个进程有不同的运行时间和优先级。
进程信息如下:进程A:运行时间10ms,优先级4进程B:运行时间8ms,优先级3进程C:运行时间6ms,优先级2进程D:运行时间4ms,优先级1进程E:运行时间2ms,优先级5实验步骤:1.先来先服务(FCFS)调度算法实验:将上述进程按照先来先服务的原则排序,运行对应的模拟程序,观察每个进程的运行时间、完成时间和等待时间。
2.最短作业优先(SJF)调度算法实验:将上述进程按照运行时间的大小排序,运行对应的模拟程序,观察每个进程的运行时间、完成时间和等待时间。
3.优先级调度算法实验:将上述进程按照优先级的大小排序,运行对应的模拟程序,观察每个进程的运行时间、完成时间和等待时间。
4.时间片轮转(RR)调度算法实验:设置一个时间片大小,将上述进程按照先来先服务的原则排序,运行对应的模拟程序,观察每个进程的运行时间、完成时间和等待时间。
实验结果:通过模拟实验,我们可以得到每个进程的运行时间、完成时间和等待时间。
对于FCFS算法,进程的运行顺序是按照先来先服务的原则,因此进程A首先得到处理器资源并完成运行,其它进程依次按照到达顺序得到资源。
因此,对于进程A、B、C、D、E,它们的完成时间分别是10ms、18ms、24ms、28ms和30ms,等待时间分别是0ms、10ms、18ms、24ms和28ms。
对于SJF算法,进程的运行顺序是按照运行时间的大小,即短作业优先。
因此,进程E首先得到处理器资源并完成运行,其它进程依次按照运行时间的大小得到资源。
对于进程E、D、C、B、A,它们的完成时间分别是2ms、6ms、12ms、20ms和30ms,等待时间分别是0ms、2ms、6ms、12ms和20ms。
反馈调度算法实验报告

一、实验目的本次实验旨在通过模拟操作系统中的反馈调度算法,加深对进程调度过程的理解,掌握不同调度算法的原理和实现方法,并分析其优缺点。
实验内容包括实现三种反馈调度算法:先来先服务(FCFS)、时间片轮转(RR)和多级反馈队列(MFQ)。
二、实验内容1. 数据结构设计本实验采用进程控制块(PCB)来表示进程,PCB包含以下信息:- 进程名- 到达时间- 需要运行时间- 已运行时间- 进程状态(就绪、运行、完成)2. 调度算法实现(1)先来先服务(FCFS)调度算法FCFS算法按照进程到达就绪队列的顺序进行调度,即先到达的进程先执行。
具体实现步骤如下:- 将所有进程按到达时间排序,形成就绪队列。
- 当CPU空闲时,从就绪队列中取出第一个进程执行,执行完毕后,再取出下一个进程执行。
(2)时间片轮转(RR)调度算法RR算法将CPU时间划分为时间片,每个进程轮流占用CPU执行一个时间片。
具体实现步骤如下:- 将所有进程按到达时间排序,形成就绪队列。
- 当CPU空闲时,从就绪队列中取出第一个进程执行,执行一个时间片。
- 如果进程执行完毕,则将其状态设置为完成;如果进程未执行完毕,则将其状态设置为就绪,并插入就绪队列末尾。
- 继续执行下一个进程,直到所有进程执行完毕。
(3)多级反馈队列(MFQ)调度算法MFQ算法将就绪队列分为多个优先级队列,每个队列具有不同的时间片长度。
具体实现步骤如下:- 将所有进程按到达时间排序,形成就绪队列。
- 将就绪队列分为多个优先级队列,优先级越高,时间片越短。
- 当CPU空闲时,从最高优先级队列中取出第一个进程执行,执行一个时间片。
- 如果进程执行完毕,则将其状态设置为完成;如果进程未执行完毕,则将其状态设置为就绪,并插入下一个优先级队列的末尾。
- 如果当前优先级队列中的所有进程都执行完毕,则降低优先级,继续执行下一个优先级队列的进程。
三、实验结果分析1. FCFS算法FCFS算法简单易实现,但存在“饥饿”现象,即低优先级进程可能长时间得不到调度。
反馈调度算法实验报告

反馈调度算法实验报告引言反馈调度算法是操作系统中常用的调度算法之一,它以时间片为单位,将进程划分为多个优先级队列,根据优先级和时间片长度来决定进程执行的顺序。
本实验旨在通过实际操作观察和比较不同的反馈调度算法在不同场景下的表现,并分析其优缺点。
实验目的1. 了解反馈调度算法的原理和实现方式;2. 熟悉使用模拟器进行实验的方法;3. 分析和评估不同反馈调度算法在不同场景下的表现。
实验环境- 操作系统:Windows 10- 开发工具:Visual Studio Code- 模拟器:C++ 编写的模拟器实验过程1. 实验准备首先,我们选择了Round Robin、Multilevel Feedback Queue 和Weighted Round Robin 三种反馈调度算法进行实验。
并计划使用不同的进程数据集来模拟不同的场景。
2. 实验步骤2.1 实验一:Round Robin 调度算法在第一个实验中,我们准备了一个包含3 个进程的数据集,每个进程分别需要执行不同的时间。
我们设置了一个时间片长度为2 个时间单位。
通过模拟器运行实验,观察每个进程的执行顺序和等待时间。
2.2 实验二:Multilevel Feedback Queue 调度算法在第二个实验中,我们准备了一个包含5 个进程的数据集,每个进程的时间片长度会随着优先级的提高而增加。
我们设置了3 个优先级队列,初始时间片长度分别为1、2 和4 个时间单位。
通过模拟器运行实验,观察不同优先级队列中进程的执行情况。
2.3 实验三:Weighted Round Robin 调度算法在第三个实验中,我们准备了一个包含4 个进程的数据集,每个进程的时间片长度由权重决定。
我们设置了进程的权重分别为1、2、3 和4。
通过模拟器运行实验,观察不同权重的进程在调度中的表现。
3. 实验结果与分析通过观察实验结果,我们得到了不同调度算法在不同场景下的表现。
对于Round Robin 调度算法,它公平地轮流执行每个进程,避免了进程长时间等待,但当进程的执行时间过长时,会导致延迟增加。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
JLU《操作系统》课程设计[基于反馈(Feed Back,FB)排队算法的CPU调度的模拟实现]程序代码:// 223.cpp : Defines the entry point for the console application.//#include "stdafx.h"#include <STRING.H> //Definitions for memory and string functions.#include <CTYPE.H> //Defines the ctype macros.#include <MALLOC.H> //memory management functions and variables.#include <STDIO.H>#include <STDLIB.H>#include <IO.H> //Definitions for low level I/O functions.#include <PROCESS.H> //Symbols and structures for process management.#include <CONIO.H> //Direct MSDOS console input/output.#include <WINDOWS.H>#include <TIME.H> // Struct and function declarations for dealing with time. #include <DOS.H> //Defines structs, unions, macros, and functions for dealing //with MSDOS and the Intel iAPX86 microprocessor family.// 函数结果状态代码#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2//////////////////////////////////////////typedef int Status; //指定用Status和Boolean代表int类型typedef int Boolean;//////////////////////////////////////////typedef struct QNode{char name[5];int time;int timeType;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front;//队头指针QueuePtr rear; // 队尾指针}LinkQueue;int count=0; //时间计数变量LinkQueue qRun,qWait,qReady1,qReady2,qReady3,qReady4;//////////////////////////////////////////////////////////////////////////void menu1();void menu2();void gotoxy(int x,int y);void clrscr(void); //清屏函数void clreol(void); //在文本窗口中清除字符到行末void clreoscr(void); //clear end of screenStatus InitQueue(LinkQueue &Q);Status creatPro(LinkQueue &quePro);void dealTime();void runPro(void);void run();void wait();void wake();void endPro();////////////////////////////////////////////////////////////////////////////DOS界面坐标定位函数/////////////////////////////////////////////////////void gotoxy(int x,int y){CONSOLE_SCREEN_BUFFER_INFO csbiInfo; //variablendklaration HANDLE hConsoleOut;hConsoleOut = GetStdHandle(STD_OUTPUT_HANDLE);GetConsoleScreenBufferInfo(hConsoleOut,&csbiInfo);csbiInfo.dwCursorPosition.X = x; //cursorposition X koordinate festlegencsbiInfo.dwCursorPosition.Y = y; //cursorposition Y koordinate festlegenSetConsoleCursorPosition(hConsoleOut,csbiInfo.dwCursorPosition); //den cursor an die festgelegte koordinate setzen}Status InitQueue(LinkQueue &Q){ // 构造一个空队列Qif(!(Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode))))exit(OVERFLOW);Q.front->next=NULL;return OK;}Status EnQueue(LinkQueue &Q,char e[5],int proTime,int tType){ // 插入元素e为Q的新的队尾元素QueuePtr p;if(!(p=(QueuePtr)malloc(sizeof(QNode)))) // 存储分配失败exit(OVERFLOW);strcpy(p->name,e);p->time=proTime;p->timeType=tType;p->next=NULL;Q.rear->next=p;Q.rear=p;return OK;}Status DeQueue(LinkQueue &Q,char e[5]){ // 若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR QueuePtr p;if(Q.front==Q.rear)return ERROR;p=Q.front->next;strcpy(e,p->name);Q.front->next=p->next;if(Q.rear==p)Q.rear=Q.front;free(p);return OK;}Status QueueTraverse(LinkQueue &Q,int x,int y){QueuePtr p;p=Q.front->next;while(p){gotoxy(x,y);printf("%s",p->name);gotoxy(x,y+1);printf("%d",p->time);p=p->next;x+=6;}printf("\n");return OK;}void print(){if(qRun.front!=qRun.rear){QueueTraverse(qRun,17,5);}if(qWait.front!=qWait.rear){QueueTraverse(qWait,17,8);}if(qReady1.front!=qReady1.rear){QueueTraverse(qReady1,17,11);}if(qReady2.front!=qReady2.rear){QueueTraverse(qReady2,17,14);}if(qReady3.front!=qReady3.rear){QueueTraverse(qReady3,17,17);}if(qReady4.front!=qReady4.rear){QueueTraverse(qReady4,17,20);}}Status creatPro(LinkQueue &quePro){char proName[5];int proTime;QueuePtr p;b: gotoxy(22,3);printf("进程名: ");gotoxy(36,3);printf("所需时间: ");gotoxy(30,3);scanf("%s",&proName);gotoxy(46,3);scanf("%d",&proTime);if(proTime<=0){gotoxy(22,3);printf("信息提示: 输入时间错误!请按Enter键返回!");gotoxy(15,3); getchar();getchar();gotoxy(0,0);menu1();goto b;}getchar();if(!(p=(QueuePtr)malloc(sizeof(QNode)))) // 存储分配失败exit(OVERFLOW);strcpy(p->name,proName);p->time=proTime;p->timeType=10; //进入时间片为10的就绪队列,即优先级最高的就绪队列p->next=NULL;quePro.rear->next=p;quePro.rear=p;return OK;}void dealTime(){char e[5];int tType=qRun.front->next->timeType;++count;qRun.front->next->time--;if(qRun.front->next->time==0){DeQueue(qRun,e);runPro();count=0;}elseif(qRun.front->next->timeType==count){if(qRun.front->next->timeType==10)EnQueue(qReady2,qRun.front->next->name,qRun.front->next->time,tType+10); if(qRun.front->next->timeType==20)EnQueue(qReady3,qRun.front->next->name,qRun.front->next->time,tType+20);if(qRun.front->next->timeType==40)EnQueue(qReady4,qRun.front->next->name,qRun.front->next->time,80);if(qRun.front->next->timeType==80)EnQueue(qReady4,qRun.front->next->name,qRun.front->next->time,80);DeQueue(qRun,e);runPro();count=0;}}void runPro(void){char e[5];int pTime,f1=0,f2=0,f3=0,f4=0;if(qReady1.front!=qReady1.rear){pTime=qReady1.front->next->time;EnQueue(qRun,qReady1.front->next->name,pTime,qReady1.front->next->timeType);DeQueue(qReady1,e);f1=1; }else{if(qReady2.front!=qReady2.rear){pTime=qReady2.front->next->time;EnQueue(qRun,qReady2.front->next->name,pTime,qReady2.front->next->timeType); DeQueue(qReady2,e);f2=1;}else{if(qReady3.front!=qReady3.rear){pTime=qReady3.front->next->time;EnQueue(qRun,qReady3.front->next->name,pTime,qReady3.front->next->timeType);DeQueue(qReady3,e);f3=1;}else{if(qReady4.front!=qReady4.rear){pTime=qReady4.front->next->time;EnQueue(qRun,qReady4.front->next->name,pTime,qReady4.front->next->timeType);DeQueue(qReady4,e);f4=1;}}}}gotoxy(0,4);menu2();if(f1==0 && f2==0 && f3==0 && f4==0){gotoxy(0,0);menu1();gotoxy(22,3);printf("信息提示:无就绪进程,请输入其他功能选项!");}gotoxy(0,4);menu2();}void run(){if(qRun.front==qRun.rear)runPro();elsedealTime();}void endPro(){char e[5];if(qRun.front==qRun.rear){gotoxy(0,0);menu1();gotoxy(22,3);printf("信息提示:无运行进程,请按Enter键运行进程!");gotoxy(15,3);}else{DeQueue(qRun,e);gotoxy(0,0);menu1();gotoxy(22,3);printf("信息提示:选择菜单功能或按Enter键执行进程!");gotoxy(0,4);menu2();print();} }void wait(){char e[5];if(qRun.front!=qRun.rear){EnQueue(qWait,qRun.front->next->name,qRun.front->next->time,qRun.front->next->timeType); DeQueue(qRun,e);gotoxy(0,4);menu2();print();gotoxy(22,3);printf("信息提示: 选择菜单功能或按Enter键执行进程!");} else{gotoxy(0,0);menu1();gotoxy(22,3);printf("信息提示:无运行进程,请输入其他功能选项!");}}void wake(){char e[5];if(qWait.front!=qWait.rear){EnQueue(qReady1,qWait.front->next->name,qWait.front->next->time,qWait.front->next->timeType );DeQueue(qWait,e);gotoxy(0,4);menu2();print();gotoxy(22,3);printf("信息提示: 选择菜单功能或按Enter键执行进程!");}else{gotoxy(0,0);menu1();gotoxy(22,3);printf("信息提示:无等待进程,请输入其他功能选项!");}}void menu1(){printf(" ┏━━━━━━━┳━━━━━━┳━━━━━━┳━━━━━━┳━━━━━━┓\n");printf(" ┃ 1-> 创建进程┃2-> 撤销进程┃3-> 阻塞进程┃4-> 唤醒进程┃0->退出系统┃\n");printf(" ┣━━━━━━━╋━━━━━━┻━━━━━━┻━━━━━━┻━━━━━━┫\n");printf(" ┃菜单选择: ┃┃\n");}void menu2(){printf(" ┣━━━━━┳━┻┳━━┳━━┳━━┳━━┳━━┳━━┳━━┳━━┳━━┫\n");printf(" ┃Run: ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┃Time ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┣━━━━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━┫\n");printf(" ┃Wait: ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┃Time ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┣━━━━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━┫\n");printf(" ┃Ready1 ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┃Time:10 ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┣━━━━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━┫\n");printf(" ┃Ready2 ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┃Time:20 ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┣━━━━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━┫\n");printf(" ┃Ready3 ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┃Time:40 ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┣━━━━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━┫\n");printf(" ┃Ready4 ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┃Time:80 ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┗━━━━━┻━━┻━━┻━━┻━━┻━━┻━━┻━━┻━━┻━━┻━━┛\n");}void main(){char a=NULL;system("color 0B");InitQueue(qRun);InitQueue(qWait);InitQueue(qReady1);InitQueue(qReady2);InitQueue(qReady3);InitQueue(qReady4);menu1();menu2();gotoxy(15,3);scanf("%c",&a);while(1){gotoxy(0,0);menu1();switch(a){case '1':creatPro(qReady1);print();gotoxy(22,3);printf("信息提示: 选择菜单功能或按Enter键执行进程!");while(1){f: gotoxy(15,3);a=getchar();if(a=='\n'){gotoxy(22,3);printf("信息提示: 选择菜单功能或按Enter键执行进程!"); run();gotoxy(0,4);menu2();print();}elsebreak;}getchar();break;case '2':endPro();goto f;break;case '3':wait(); goto f; print(); break;case '4':wake(); goto f; print(); break;case '0': gotoxy(22,3); exit(0); break;default:gotoxy(22,3);printf("信息提示: 输入错误!请选择正确的菜单功能选项!"); goto f;}print();}}。