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

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

基于深度强化学习的网络资源分配与调度引言在当今数字化时代,网络资源的高效分配与调度对于保障网络服务质量和提升用户体验至关重要。
而面对日益增长的网络流量和复杂多样的网络应用场景,传统的资源分配和调度方法已经无法满足需求。
因此,如何利用人工智能领域中的深度强化学习技术来优化网络资源的分配与调度问题成为了研究的热点之一。
本文将探讨基于深度强化学习的网络资源分配与调度的原理、方法和应用。
一、深度强化学习的简介1.1 强化学习的基本概念和原理强化学习是一种通过与环境交互学习最佳行为策略的机器学习方法。
其核心思想是智能系统通过不断试错和学习,从环境中获得反馈信号,通过最大化长期累计奖赏来选择最优决策。
强化学习包括智能体、环境和奖赏函数三个基本要素,并通过马尔可夫决策过程(MDP)进行建模和求解。
1.2 深度学习在强化学习中的应用深度学习是一种通过模拟人脑神经网络结构和算法实现的机器学习方法。
其通过多层次的神经网络结构和大量的训练数据,实现了高度复杂的特征提取和模式识别能力。
深度学习在强化学习中的应用主要体现在价值函数的近似和策略搜索的优化等方面。
通过使用深度神经网络来拟合状态-动作对的价值函数,可以更好地解决高维状态空间问题;而通过使用强化学习算法对策略进行优化,在复杂环境中实现了更高效的决策。
二、基于深度强化学习的网络资源分配与调度原理2.1 网络资源分配与调度问题的背景和挑战网络资源分配与调度问题是指在有限资源条件下,如何合理地分配和调度网络中的带宽、存储和计算等资源,以满足不同网络应用的服务质量要求。
随着网络规模的不断扩大和用户对高带宽、低延迟的需求日益增长,资源分配和调度问题变得愈发复杂和困难。
2.2 深度强化学习在网络资源分配与调度中的应用深度强化学习方法在网络资源分配与调度问题中的应用主要可以分为以下几个方面:(1)基于深度Q网络(Deep Q-Network,DQN)的带宽分配:通过使用DQN算法,将网络的带宽分配问题建模为MDP,通过不断学习和优化网络的带宽分配策略,实现带宽的智能调度和分配。
操作系统进程调度算法模拟实验报告

操作系统进程调度算法模拟实验报告一、实验目的本实验旨在深入理解操作系统的进程调度算法,并通过模拟实验来探究不同调度算法之间的差异和优劣。
二、实验原理操作系统的进程调度算法是决定进程执行顺序的重要依据。
常见的调度算法有先来先服务(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)算法的平均等待时间最短,说明该算法在短作业的情况下能够有效地减少等待时间。
操作系统 多级反馈队列算法例题

操作系统:多级反馈队列算法例题在操作系统中,调度算法是用来管理和执行进程的重要工具。
其中,多级反馈队列调度算法是一种经典的调度算法,它能够根据进程的优先级和执行情况动态地调整进程的执行顺序,以达到更高效的资源利用和更快速的响应时间。
接下来,我们将通过一个例题来深入探讨多级反馈队列调度算法的原理和应用。
假设有5个进程,它们的执行时间分别为3、5、2、7和4个单位。
我们可以构建一个具有3个队列的多级反馈队列调度算法,每个队列的优先级不同,分别为高、中、低。
在这个例题中,我们将以此为例,进行具体的调度过程。
将这5个进程按照它们的到达时间依次加入到第一个队列中,然后按照先来先服务的原则进行调度。
假设第一个队列的时间片为2个单位。
在第一个队列中,我们依次执行进程1和进程2,并在时间片用完之后将它们移到第二个队列中。
此时,这两个进程还有未完成的执行时间,因此它们进入第二个队列的队尾。
接下来,轮到第三个进程加入到第一个队列中,并按照相同的规则进行调度。
在第一个队列中,我们执行进程3的两个时间片,然后将它移到第二个队列中。
此时,第一个队列已经没有进程,因此我们开始执行第二个队列中的进程。
依次类推,直到所有的进程执行完毕。
通过这个例题,我们可以清楚地看到多级反馈队列调度算法是如何根据进程的优先级和执行情况进行动态调整的。
它能够兼顾短作业和长作业,保证了系统的公平性和响应速度。
总结起来,多级反馈队列调度算法是一种高效的进程调度算法,它能够根据进程的优先级和执行情况动态地调整执行顺序,以提高系统的资源利用和响应速度。
通过深入地理解和应用这个调度算法,我们能够更好地优化系统性能,提升用户体验。
在我看来,多级反馈队列调度算法是非常值得学习和掌握的一种调度算法。
它不仅能够帮助我们更好地理解操作系统的工作原理,还能够在实际的系统设计和优化中发挥重要作用。
我会继续深入研究这个算法,并将其应用到实际的项目中去。
希望本文能够帮助您更深入地理解多级反馈队列调度算法,并对操作系统有更全面、深刻和灵活的理解。
多级反馈队列调度算法的原理 -回复

多级反馈队列调度算法的原理-回复什么是多级反馈队列调度算法?多级反馈队列调度算法是一种进程调度算法,根据进程的优先级和执行时间,将进程分配到不同的处理队列中,并进行轮转执行。
该算法采用了多个队列和反馈机制,使得进程能够相对公平地竞争CPU资源,并且具有较高的响应速度和吞吐量。
多级反馈队列调度算法的原理是什么?多级反馈队列调度算法的原理主要包括以下几个方面:1. 多个队列:多级反馈队列调度算法采用多个队列来存放进程。
一般来说,队列的数量不固定,可以根据实际情况进行调整。
每个队列都有一个不同的优先级,每个优先级代表了不同的执行时间片长度。
2. 进程分配:当一个进程被提交到系统中时,多级反馈队列调度算法会首先将它分配到最高优先级的队列中。
如果该进程在一个时间片内无法完成,那么它就会被移到下一级队列中,并且等待下一次执行。
同样的,进程在下一级队列中也无法完成时,就会被移到更低优先级的队列中。
这个过程会一直持续到该进程执行完成或被终止。
3. 时间片分配:每个队列中的进程都按照其优先级分配时间片。
优先级较高的队列拥有短的时间片,优先级较低的队列拥有长的时间片。
这个机制可以保证高优先级的进程更快地获得CPU资源,从而提高系统的响应速度。
4. 反馈机制:多级反馈队列调度算法还采用了反馈机制,即当进程在一个队列中等待了一定时间之后,它会被移到一个更高优先级的队列中。
这个机制可以有效地解决进程长时间处于低优先级队列中的问题,从而提高处理效率和响应速度。
多级反馈队列调度算法的实现步骤是什么?多级反馈队列调度算法的实现步骤包括以下几个方面:1. 初始化:初始化多个队列,每个队列都有一个不同的优先级,同时初始化时间片大小和进程调度参数。
2. 进程分配:当一个进程被提交到系统中时,将其分配到最高优先级的队列中。
3. 时间片分配:按照优先级分配时间片,优先级较高的队列拥有较短的时间片,优先级较低的队列拥有较长的时间片。
4. 进程执行:从最高优先级的队列中取出一个进程执行,在一个时间片内完成或被抢占后,将进程移到下一级队列中等待执行。
进程调度实验报告

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

操作系统中的CPU调度算法实现与优化随着计算机技术的不断发展,操作系统作为计算机的重要组成部分已经成为了现代计算机的核心,操作系统的性能对整个计算机的运行和效率有着至关重要的影响。
其中,CPU调度算法是操作系统中的核心内容之一,其对操作系统的性能有着直接的影响作用。
什么是CPU调度算法?CPU调度是操作系统中的一项关键任务,主要负责分配CPU 时间片给各个进程,以实现多进程并发执行。
而CPU调度算法则是CPU调度的关键之一,其主要作用是决定进程在什么情况下能够获取CPU使用权,进程的优先级、时间片大小等等影响着操作系统的性能。
常见的CPU调度算法:1. 先来先服务调度算法(FCFS)先来先服务调度算法,即按照作业到达的先后顺序分配CPU 时间片,每个进程在进入就绪队列后,按照行到达时间先后依次排队等待调度,先到达的进程先分配CPU时间片,然后完成执行后才分配给后续的进程。
这种算法不需要任何额外的参数,其实现简单,但是当进程短任务和长任务交织时,会导致短任务长时间等待,并且也不能满足响应时间的需求。
2. 短作业优先调度算法(SJF)短作业优先调度算法,即根据进程的需要任务量分配CPU时间片,等待时间短的任务优先获取CPU使用权,使得短任务能够更快的得到执行,提高系统的响应速度。
但是,该定调度算法仅适用于批处理系统,当进程数量庞大时,无法快速准确地预估进程的任务量,如果预估不准,就会出现长任务等待短任务的情况。
3. 优先级调度算法优先级调度算法是基于进程的优先级确定分配CPU时间片的方法,一般根据进程的特性,为不同进程设置不同的优先级,每次调度时以优先级高的进程优先获取CPU使用权,直到时间片用完或者进程执行结束。
优先级调度算法有着良好的响应性,但不利于低优先级进程,经常会出现饥饿的情况。
4. 时间片轮转调度算法时间片轮转调度算法指将CPU时间片分成一定长度的时间段,按照进程到达的先后依次分配时间片,等待不同进程请求时间的到达,一旦时间到达,则进行轮换,并将未利用完的时间片赋予下一个进程。
多级反馈队列调度算法

多级反馈队列调度算法:(FB算法)(1)设置多个不同优先级的就绪队列,并赋予各个队列大小不同时间片,使得优先级愈高的队列时间片愈小。
(2)新就绪进程总是先进入第一级(即最高优先级)队列的末尾,并按FIFO原则等待调度;当轮到该进程执行时,如它能在规定时间片内完成,便可准备撤离系统,否则将它转入第二级队列末尾,再同样按FIFO原则等待调度;如果它在第二级队列上运行一个时间片后仍未完成,再依次将它转入第三极队列。
如此下去,当一个长作业从第一级队列降到最后一级队列时,便在该队列中采取时间片轮转方式运行。
(3)系统总是调度第一级队列上的进程执行;仅当第一级队列为空时,才调度第二级队列上的进程执行‘类推之,仅当第1~(i-1)为空时,才调度第i级队列上的进程执行。
多级反馈队列算法可有很多变形,如当处理机正在为第I级队列上的进程服务时,又有新进程进入优先级最高的队列,此时,既可采用立即抢占的方式,将正在执行的进程插入第i级队列的末尾,并将处理机分配给新进程;也可以只按时间片进行抢占,等正在执行的进程时间片用完或它不需要CPU时再进行CPU调度。
例题如下:进程到达和需服务时间进程到达时间服务时间A 0 3B 2 6C 4 4D 6 5E 8 2RR算法中,就绪进程按FIFO方式排列,CPU总是分配给队首的进程,并只能执行一个时间片;FB算法将就绪进程排成多个不同优先权及时间片的队列,就绪进程总是按FIFO方式先进入优先权最高的队列,CPU也总是分配给较高优先权队列上的队首进程,若执行一个时间片仍未完成,则转入下一级队列的末尾,最后一级队列采用时间片轮转方式进行调度。
5101520A B ED C A B ED C A B ED C 05101520RR (q=1)FB (q=2i-1)FB (q=2i-1)立即抢占说明:q=2i-1,其中的i表示是在哪个级的队列上,所以,优先级愈高的队列时间片愈小(原理)(1)q=21-1=1执行A,然后放入到第二级队列末尾(2)q=22-1=2A执行结束此时B已经在2秒时到达,放在第一队列的末尾。
- 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();}}。