基于反馈(Feed Back,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)调度算法。

多级反馈队列调度算法是一种综合性的调度算法,根据进程的优先级和执行时间进行动态调整。

在本次实验中,我们通过模拟多个进程的执行和不同优先级队列的调度,观察其平均等待时间和平均周转时间。

实验结果表明,多级反馈队列调度算法能够兼顾短作业和长作业,提高了系统的整体性能。

四、实验总结。

通过本次实验,我们深入理解了不同进程调度算法的特点和适用场景。

操作系统进程调度算法模拟实验

操作系统进程调度算法模拟实验

操作系统进程调度算法模拟实验进程调度是操作系统中一个重要的功能,它决定了哪些进程能够获得处理器资源以及如何按照一定的策略来分配这些资源。

为了更好地理解进程调度算法的工作原理,我们可以进行一个模拟实验来观察不同算法的表现效果。

实验设想:我们设想有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。

使用动态优先权的进程调度算法的模拟实验

使用动态优先权的进程调度算法的模拟实验

使用动态优先权的进程调度算法的模拟实验进程调度算法是操作系统中对进程进行调度的一种策略,动态优先权调度算法是其中一种常用的调度算法。

下面将对动态优先权调度算法进行模拟实验,并对实验结果进行分析。

首先,我们定义进程的属性包括进程编号、到达时间、服务时间、优先权和完成时间等。

动态优先权调度算法的基本思想是根据进程的优先权决定下一个被调度的进程,优先权越高,被调度的机会越大。

实验过程如下:1.创建一个进程队列,用来存放待调度的进程。

2.输入进程的个数,并依次输入每个进程的到达时间、服务时间和优先权。

3.将所有进程按照到达时间进行排序。

4.从排好序的进程队列中选择优先权最高的进程,即优先权最大的进程。

5.通过执行该进程进行模拟,更新进程队列中的进程信息。

6.根据更新后的进程信息,重新选择下一个被调度的进程。

7.重复步骤5和6,直到所有进程执行完毕。

对于每个进程,我们可以记录其等待时间、周转时间和带权周转时间。

等待时间即为该进程在就绪队列中等待的时间,周转时间是指从进程提交到完成的时间,即完成时间减去到达时间,带权周转时间是指每个进程的周转时间除以服务时间,用来评估进程的调度效果。

下面是一个动态优先权调度算法的模拟实验示例:```pythonclass Process:self.id = idself.priority = prioritydef __lt__(self, other):return self.priority < other.prioritydef dynamic_priority_scheduling(processes):queue = []while processes or queue:for process in processes:queue.append(process)processes.remove(process)queue.sort(reverse=True) # 根据进程的优先权进行排序if queue:process = queue.pop(0)for p in queue:if __name__ == '__main__':n = int(input("Enter the number of processes: "))processes = []for i in range(n):priority = int(input("Enter priority for process {}:".format(i+1)))dynamic_priority_scheduling(processes)```以上代码定义了一个Process类来表示进程,并使用动态优先权调度算法对进程进行调度。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

JLU《操作系统》课程设计[基于反馈(Feed Back,FB)排队算法的CPU调度的模拟实现]算法设计:多级反馈队列调度算法,不必事先知道各进程所需的进程时间,而且还可以满足各种类型进程的需要,因而它是目前被公认的一种较好的进程调度算法。

在采用多级反馈队列调度算法的系统中,调度算法的实施过程如下:1.设置多个就绪队列,并为各个队列赋予不同的优先级。

第一个队列的优先权最高,第二个的次之,其余各队列的优先权逐个降低。

该算法赋予各个队列中进程执行时间片的大小也各不相同,在优先权愈高的队列中,为每个进程所规定的执行时间片就愈小。

例如,第二个队列的时间片要比第一个队列的时间片长一倍,……,第I+1个队列的时间片要比第I个队列的时间片长一倍。

2.一个新进程进入内存后,首先将它放在第一队列的末尾,按FCFS原则排队等待调度。

当轮到该进程执行时,如它能在该时间片内完成,便可准备撤离系统,如果它在一个时间片结束时尚未完成,调度程序便将该进程转入第二队列的末尾,再同样地按FCFS原则等待调度执行;如果它在第二队列中运行一个时间片后仍未完成,再依次将它放入第三队列,……,如此下去,当一个长作业(进程)从第一队列依次降到第n队列后,在第n队列中便采取按时间片轮转的方式进行。

3.仅当第一队列空闲时,调度程序才调度第二队列中的进程运行;仅当第1~(I-1)队列均空时,才会调度第I队列中为某进程服务时,又有新进程进入优先权较高的队列(第1~(I-1)中的任何一个队列),则此时新进程将抢占正在运行进程的处理机,即由调度程序把正在运行的进程放回到第I队列的末尾,把处理机分配给新到的高优先权进程。

任务分工及各分工实现方法:组长学号及姓名:分工:一直以来担任组长,要做的事很多,既要给组员分排任务,安排每个人的在课程设计要完成的任务,又要协调各个之间的分歧与合作,尽量融合大家的各种想法,汇总好的建议,好的做法,达到我们组的团体合作精神,这样才能把课程设计做的更好。

负责算法的总体设计程序的全局变量和编写多级调度函数,整理每个人的工作,组合成整个算法。

听取大家提出的问题和建议,完善算法。

组员1学号及姓名:分工:设计程序中主要的进程控制块信息及其需要的变量,交由组讨论决定。

编写系统中模块的程序进程插入进程到队尾、取对头进程函数。

参与程序的调试。

组员2学号及姓名:分工:设计程序多级反馈队列的具体实现方式,由组共同讨论决定。

编写就绪队列创建函数,以及将就绪队列链栈起来。

参与测试程序。

测试结果:程序代码:// 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();}}。

相关文档
最新文档