处理器调度
第3章处理器调度

第3章处理器调度一、填空1.一个操作系统的可扩展性,是指该系统能够跟上先进计算机技术发展的能力。
2.在引入线程的操作系统中,线程是进程的一个实体,是进程中实施调度和处理机分派的基本单位。
3.一个线程除了有所属进程的基本优先级外,还有运行时的动态优先级。
4.进程调度程序具体负责处理器的分配。
5.为了使系统的各种资源得到均衡使用,进行作业调度时,应该注意cpu繁忙型作业和输入/输出繁忙型作业的搭配。
6.总的来说,进程调度有两种方式,即剥夺方式和不剥夺方式。
7.作业被系统接纳后到运行完毕,一般还需要经历后备、运行和完成三个阶段。
8.假定一个系统中的所有作业同时到达,那么使作业平均周转时间为最小的作业调度算法是短作业优先调度算法。
二、选择1.计算机系统在执行时,会自动从目态变换到管态。
A.P操作B.V操作C.系统调用D.I/O指令2.在Windows 2000/XP中,只有状态的线程才能成为被切换成运行状态,占用处理器执行。
A.备用B.就绪C.等待D.转换3.Windows 2000/XP是采用来实现对线程的调度管理的。
A.线程调度器就绪队列表B.线程调度器就绪队列表、就绪位图C.线程调度器就绪队列表、就绪位图、空闲位图D.线程调度器就绪队列表、空闲位图4.在Windows 2000/XP里,一个线程的优先级,会在时被系统降低。
A.时间配额用完B.请求I/O C.等待消息D.线程切换6.由各作业JCB形成的队列称为。
A.就绪作业队列B.阻塞作业队列C.后备作业队列D.运行作业队列7.既考虑作业等待时间,又考虑作业执行时间的作业调度算法是。
A.响应比高者优先B.短作业优先C.优先级调度D.先来先服务8.作业调度程序从处于状态的队列中选取适当的作业投入运行。
A.就绪B.提交C.等待D.后备9.是指从作业提交到作业完成的时间间隔。
A.周转时间B.响应时间C.等待时间D.运行时间三、问答1.为什么说响应比高者优先作业调度算法是对先来先服务以及短作业优先这两种调度算法的折中?2.短作业优先调度算法总能得到最小的平均周转时间吗?为什么?3.证明作业调度算法中短作业优先调度算法具有最小平均等待时间。
操作系统中的CPU调度

操作系统中的CPU调度一、CPU调度的基本概念CPU调度是操作系统的一个非常重要的功能,它控制着CPU 在多任务环境下的运作。
在多任务环境下,CPU必须要对不同的进程进行处理,CPU调度就是指根据一定的算法,在所有可执行的进程中选择一个进程,让它占用CPU,运行一段时间,并在执行完毕后释放CPU,然后选择下一个可执行的进程进行处理,这样就能够合理地利用CPU资源,提高系统的响应速度和吞吐量。
二、CPU调度的基本算法CPU调度的主要任务是在可执行的进程中选择一个进程让其运行,并在一定的时间之后切换到另一个进程进行处理。
但是,在实际中需要考虑的问题是如何选择进程,并且进程切换所带来的开销不能太大。
因此,CPU调度的算法就成了关键。
CPU调度算法主要有以下几种:1. 先来先服务算法(FCFS)FCFS是最早的调度算法,它简单易懂,就是按照进程到达的顺序来排序,先到达的进程先执行,完成后才能运行后面到达的进程。
但是,这种算法存在“饥饿”现象,即如果某个进程运行时间过长,其他进程就无法得到及时的处理。
2. 最短作业优先算法(SJF)SJF算法是根据进程的运行时间来排序的。
处理器会选择那些需要时间最短的进程进行处理。
这种算法速度快,但是会出现“饥饿”现象,即某些进程的运行时间太长,导致其他进程无法得到及时的处理。
3. 时间片轮转算法(RR)RR算法是在时间片为单位对进程进行轮流处理。
每个进程分配一个时间片,当时间片用完时,处理器会停止这个进程的运行,并且把它放到等待队列的末尾,然后从队列的头部选择下一个进程。
这种算法能够避免“饥饿”的现象,但是会带来一定的上下文切换开销。
4. 优先级算法(Priority)Priority算法是根据进程的优先级进行判断的。
进程的优先级越高,就越容易被处理器调度。
但是,这种算法存在的问题就是某些优先级低的进程可能会一直得不到执行。
5. 多级反馈队列算法(MFQ)MFQ算法是一种复杂的算法,它将进程划分为多个队列,分配不同的时间片用于不同的队列。
操作系统中的CPU调度算法实现与优化

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

设计一个按优先数调度算法实现处理器调度的程序处理器调度是操作系统中重要的任务之一,负责决定在多个可执行任务之间如何分配处理器时间。
在处理器调度中,按优先数调度算法是一种常见的策略。
本文将介绍如何设计一个按优先数调度算法实现处理器调度的程序。
一、定义任务在实现处理器调度之前,首先需要定义可执行的任务。
一个任务可以由多个属性来描述,包括优先级、到达时间、执行时间等。
在按优先数调度算法中,每个任务都有一个优先级,优先级越高表示任务的重要性越高。
同时,每个任务还有一个到达时间,即任务进入调度器的时间点。
最后,每个任务还有一个执行时间,表示任务完成所需要的时间。
二、设计数据结构为了表示任务,我们可以使用一个Task类来封装任务的属性,例如:```class Taskint priority; // 优先级int arrivalTime; // 到达时间int executionTime; // 执行时间};```此外,为了管理所有待调度的任务,需要使用一个队列来存储任务。
我们可以使用优先队列(Priority Queue)来实现这个队列,其中任务按照优先级的顺序排列。
当一个任务到达时,将其插入到优先队列中;当处理器空闲时,从优先队列中选择优先级最高的任务进行调度。
三、实现调度算法接下来,需要实现按优先数调度算法。
按照该算法的步骤,当一个任务到达时,将其插入到优先队列中。
当处理器空闲时,从队列中取出优先级最高的任务,并执行该任务。
如果任务未完成,则将其重新插入队列中。
如果所有任务都已完成,则调度任务结束。
以下是一个示例的按优先数调度算法实现:```PriorityQueue<Task> taskQueue; // 优先队列,按优先级排序任务void schedule(int currentTime)if (taskQueue.isEmpty()System.out.println("Processor is idle.");return;}Task currentTask = taskQueue.poll(; // 取出优先级最高的任务int remainingTime = currentTask.executionTime - (currentTime - currentTask.arrivalTime);if (remainingTime > 0)currentTask.executionTime = remainingTime;taskQueue.add(currentTask); // 将未完成的任务重新插入队列中} else}```四、模拟调度过程最后,我们可以编写一个简单的模拟函数来模拟调度器的执行过程:```void simulatint currentTime = 0; // 当前时间while (!taskQueue.isEmpty()while (!taskQueue.isEmpty( && taskQueue.peek(.arrivalTime <= currentTime)Task newTask = taskQueue.poll(;System.out.println("New task with priority " +newTask.priority + " arrived at " + currentTime + ".");taskQueue.add(newTask); // 插入新到达的任务}schedule(currentTime);currentTime++;}```在模拟函数中,我们不断地增加当前时间,直到所有任务都已完成。
操作系统原理第五章处理器调度

2)正文段(共享正文段 ) 它是进程执行程序的一部分,可为多个进程共 享执行,作为正文段的程序必须是可重入的。
3)数据段 包括:正文段程序的处理对象--数据、进程 执 行 程 序 ( 私 有 ) 及 数 据 和 ppda( 进 程 数 据 区)。
4) 用户栈
2、UNIX进程树
0进程:系统初启时由系统初启程 序建立,完成系统初启的相应工 作后,创建1进程;然后的工作有 两项,其一是进程交换(进程图 象的管理);其二是进程切换 (进程调度)。
1 进程:为系统的每个联机终端 创建一个终端进程,然后就做托 管工作。
2、3、…、n、n+1进程:终端进 程,执行程序是shell,该进程执 行是接受和执行用户键入的shell 命令,或shell命令程序。
用户创建的进程:用户的shell命 令或shell程序所创建的进程;用 户在其程序中创建的进程。
三、进程调度
操作系统为了对进程进行有效的监控, 需要维护一些与进程相关的数据结构, 记录所有进程的运行情况,并在进程让 出处理器或调度程序剥夺处于运行状态 的进程占用的处理器时,选择适当的进 程分配处理器,完成上下文的切换。我 们把操作系统内核中完成这些功能的部 分称为进程调度。
1、进程调度的功能 1)记录系统中所有进程的执行情况 PCB 2)选择占有处理器的进程 3)进行进程上下文的切换 2、进程调度的方式 1)非剥夺调度方式 2)剥夺调度方式
p_flag中的SLOAD为1,表示该进程图象在 内存,否则不在内存。
(四)创建状态
父进程创建子进程时所处的状态,目的 是保证子进程能完全复制父进程的图象。
在UNIX系统中,父进程创建一个子进程 时,子进程要复制父进程的全部的进程 图象(除proc结构外),当有内存空间 时,能很快完成复制工作,但若无内存 空间时,就要在交换区中建立子进程图 象的复本,这时父进程将自己置为创建 状态,以保证自己的图象不被调出内存。
处理器调度实验报告

一、实验目的1. 理解处理器调度的基本概念和原理;2. 掌握常用的处理器调度算法,如先来先服务(FCFS)、短作业优先(SJF)、优先级调度等;3. 分析不同调度算法的性能指标,如平均周转时间、平均带权周转时间等;4. 通过实验,提高实际操作和编程能力。
二、实验原理处理器调度是操作系统中的一个重要组成部分,其主要任务是合理分配处理器资源,使系统中的多个进程高效、有序地运行。
常见的处理器调度算法有以下几种:1. 先来先服务(FCFS):按照进程到达就绪队列的顺序进行调度,先到先服务;2. 短作业优先(SJF):优先选择运行时间最短的进程执行;3. 优先级调度:根据进程的优先级进行调度,优先级高的进程先执行;4. 时间片轮转(RR):将每个进程分配一个时间片,按照时间片轮转的方式调度进程。
三、实验内容1. 实验环境:Windows操作系统,Python编程语言;2. 实验工具:Python编程环境,如PyCharm、Spyder等;3. 实验步骤:(1)设计一个进程类,包含进程名、到达时间、运行时间、优先级等属性;(2)编写调度算法,实现FCFS、SJF、优先级调度和时间片轮转算法;(3)模拟进程执行过程,记录各个进程的执行时间、等待时间、周转时间等性能指标;(4)分析不同调度算法的性能,比较其优劣。
四、实验结果与分析1. FCFS调度算法实验结果:平均周转时间为20,平均带权周转时间为1.25。
分析:FCFS调度算法简单易实现,但可能导致进程响应时间长,不利于实时性要求高的系统。
2. SJF调度算法实验结果:平均周转时间为16,平均带权周转时间为1.2。
分析:SJF调度算法可以缩短平均周转时间,提高系统性能,但可能使长作业长时间等待,影响公平性。
3. 优先级调度算法实验结果:平均周转时间为18,平均带权周转时间为1.3。
分析:优先级调度算法可以根据进程的优先级进行调度,提高系统响应速度,但可能导致低优先级进程长时间等待。
处理器调度实验报告

处理器调度实验报告处理器调度实验报告一、实验目的处理器调度是操作系统中的重要组成部分,它负责决定哪个进程优先执行,以及如何分配处理器资源。
本次实验旨在通过模拟不同的处理器调度算法,深入了解各种算法的工作原理和优缺点。
二、实验背景在多道程序设计环境下,多个进程同时竞争有限的处理器资源。
为了提高系统的吞吐量和响应速度,需要合理地调度进程,使得每个进程都能得到公平的执行机会。
处理器调度算法的选择直接影响到系统的性能和用户体验。
三、实验内容本次实验使用模拟器来模拟不同的处理器调度算法,包括先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)和优先级调度(Priority Scheduling)。
通过对这些算法的模拟实验,我们可以观察到它们在不同场景下的表现。
四、实验过程与结果首先,我们设计了一组测试用例,每个测试用例包含若干个进程,每个进程具有不同的执行时间和优先级。
然后,我们分别使用不同的调度算法对这些进程进行调度,并记录下每个进程的等待时间和周转时间。
在FCFS算法下,进程按照到达的先后顺序依次执行。
这种算法简单直观,但是容易造成后面进程的等待时间过长,尤其是当某个进程执行时间较长时。
SJF算法根据进程的执行时间来进行调度,执行时间最短的进程先执行。
这种算法能够最大程度地减少平均等待时间,但是对于长作业来说,可能会出现饥饿现象。
RR算法将处理器的时间划分为若干个时间片,每个进程在一个时间片内执行一定的时间,然后切换到下一个进程。
这种算法能够保证每个进程都能得到执行的机会,但是对于执行时间较长的进程来说,可能会造成较大的上下文切换开销。
优先级调度算法根据进程的优先级来进行调度,优先级高的进程先执行。
这种算法可以根据不同的场景进行调整,但是可能会出现优先级反转的问题。
通过实验结果的分析,我们可以看到不同的调度算法在不同场景下的表现。
对于短作业来说,SJF算法能够最大程度地减少等待时间;对于长作业来说,RR算法能够保证公平性;而优先级调度算法则适用于一些需要特定优先级处理的场景。
处理器调度算法例题

处理器调度算法例题在操作系统的处理器调度中,哪种调度算法可能会导致饥饿现象?A. 先来先服务(FCFS)B. 短作业优先(SJF)C. 优先级调度D. 轮转调度(RR)下列哪种调度算法最有可能实现CPU的高效利用和作业的快速响应?A. 多级队列调度B. 最高响应比优先调度C. 先来先服务调度D. 短作业优先调度关于优先级调度算法,下列说法错误的是:A. 可以设置静态优先级,也可以根据进程执行情况动态调整优先级B. 优先级越高的进程越先被调度执行C. 优先级调度算法能够很好地避免饥饿现象D. 可能会产生优先级反转问题在轮转调度算法中,时间片的大小对系统性能有显著影响。
如果时间片设置得过大,可能会导致:A. 系统响应时间变长B. CPU利用率降低C. 进程切换开销增加D. 进程执行更加公平下列哪种调度算法特别适用于批处理系统?A. 短作业优先调度B. 先来先服务调度C. 优先级调度D. 多级反馈队列调度在多级队列调度算法中,通常将进程分为不同的类别或优先级,以下不属于常见分类标准的是:A. 进程大小B. 进程类型(如I/O密集型或计算密集型)C. 进程到达时间D. 进程所需服务时间关于最高响应比优先调度算法,下列说法正确的是:A. 总是先执行等待时间最长的进程B. 总是先执行服务时间最短的进程C. 综合考虑了等待时间和服务时间,以响应比为依据进行调度D. 可能导致饥饿现象,因为某些进程的响应比可能一直很低在操作系统的处理器调度中,哪种调度算法特别关注于减少进程的等待时间?A. 短作业优先调度B. 先来先服务调度C. 轮转调度D. 多级反馈队列调度。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
一、实验内容选择一个调度算法,实现处理器调度。
二、实验目的在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态.当就绪状态进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器.本实验模拟在单处理器情况下处理器调度,帮助学生加深了解处理器调度的工作.三、实验题目1、:设计一个按优先数调度算法实现处理器调度的程序。
2、设计一个按时间片轮转法实现处理器调度的程序。
四、实验提示:1、假定系统有五个进程,每一个进程用一个进程控制块PCB来代表.进程控制块的格式为: 进程名时间要求求运行时间优先数状态其中,进程名-----作为进程的标识,假设五个进程的进程名分别是P1,P2,P3,P4,P5。
指针----按优先数的大小把五个进程连成队列,用指针指出下一个进程的进程控制块首地址,最后一个进程中的指针为"0"。
要求运行时间----假设进程需要运行的单位时间数。
优先数----赋予进程的优先数,调度时总是选取优先数大的进程先执行。
状态----可假设有两种状态,"就绪"状态和"结束"状态,五个进程的初始状态都为"就绪"状态,用"R"表示,当一个进程运行结束后,它的状态变为"结束", 用"E"表示.。
在每次运行你所设计的处理器调度程序之前,为每个进程任意确定它的"优先数"和"要求运行时间"。
为了调度方便,把五个进程按给定的优先数从大到小连成队列,用一单元指出队首进程,用指针指出队列的连接情况.例:队首标志k1 k2 k3 k4 k5PCB1 PCB2 PCB3 PCB4 PCB5处理器调度总是选队首进程运行.采用动态改变优先数的办法,进程每运行一次优先数就减"1".由于本实验是模拟处理器调度,所以,对被选中的进程并不实际的启动运行,而是执行: 优先数-1要求运行时间-1来模拟进程的一次运行.提醒注意的是:在实际的系统中,当一个进程被选中运行时,必须恢复进程的现场,它占有处理器运行,直到出现等待事件或运行结束.在这里省去了这些工作。
进程运行一次后,若要求运行时间≠0,则再将它加入队列(按优先数大小插入,且置队首标志);若要求运行时间=0,则把它的状态修改为"结束",且退出队列。
若"就绪"状态的进程队列不为空,则重复上述步骤,直到所有进程都成为"结束"状态.。
在所设计的程序中应有显示或打印语句,能显示或打印每次被选中进程的进程名以及运行一次后进程对列的变化。
为五个进程任意确定一组"优先数"和"要求运行时间",启动所设计的处理器调度程序,显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程.。
2、假定系统有五个进程,每一个进程用一个进程控制块PCB来代表.进程控制块的格式为:进程名时间要求求运行时间优先数状态其中,进程名----作为进程的标识,假设五个进程的进程名分别是Q1,Q2,Q3,Q4,Q5.指针----进程按顺序排成循环队列,用指针指出下一个进程的进程控制块首地址,最后一个进程中的指针指出第一个进程的进程控制块首地址.要求运行时间----假设进程需要运行的单位时间数.已运行时间----假设进程已经运行的单位时间数,初始值为"0".状态----有两种状态,"就绪"状态和"结束"状态,初始状态都为"就绪",用"R"表示,当一个进程运行结束后,它的状态变为"结束",用"E"表示.每次运行你所设计的处理器调度程序之前,为每个进程任意确定它的"要求运行时间". 把五个进程按顺序排成循环队列,用指针指出队列连接情况.另用一标志单元记录轮到运行的进程.处理器调度总是选择标志单元指示的进程运行.由于本实验是模拟处理器调度的功能,所以,对被选中的进程并不实际启动运行,而是执行: 已运行时间+1 ,来模拟进程的一次运行,表示进程已经运行过一个单位的时间.请同学们注意:在实际的系统中,当一个进程被选中运行时,必须置上该进程可以运行的时间片值,以及恢复进程的现场,让它占有处理器运行,直到出现等待事件或运行满一个时间片.在这里省去了这些工作,仅用"已运行时间+1"来表示进程已经运行满一个时间片. 进程运行一次后,应把该进程的进程控制块中的指针值送到标志单元,以指示下一个轮到运行的进程.同时,应判断该进程的要求运行时间与已运行时间,若该进程要求运行时间≠已运行时间,则表示它尚未执行结束,应待到下一轮时再运行.若该进程的要求运行时间=已运行时间,则表示它已经执行结束,应把它的状态修改为"结束"(E)且退出队列.此时,应把该进程的进程控制块中的指针值送到前面一个进程的指针位置.若"就绪"状态的进程队列不为空,则重复上述步骤,直到所有进程都成为"结束"状态. 在所设计的称序中应有显示或打印语句,能显示或打印每次被选中进程的进程名以及运行一次后进称对列的变化.为五个进程任意确定一组"要求运行时间",启动所设计的处理器调度程序,显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程.程序:#include "stdio.h"#include "stdlib.h"#include "time.h"#include "malloc.h"typedef struct PCB {char pName[8]; //进程名int nt; //要求运行时间int ct; //已经运行时间int priority; //优先级char state; //状态struct PCB *next;}PCB,*PCBPtr;int menu_select(){char c;do{system("cls");printf("\t\t**** 请选择需要的方法****\n");printf("\t\t | 1. 优先级算法|\n");printf("\t\t | 2. 时间片轮转法|\n");printf("\t\t | 3. 退出|\n");printf("\t\t*****************************************\n");printf("\t\t\t请选择(1-3):");c=getchar();}while(c<'0'||c>'4');return(c-'0');}typedef struct LinkQueue{PCBPtr front;PCBPtr rear;}SqQueue;void InitQueue(SqQueue *Q){Q->front = (PCBPtr)malloc(sizeof(PCB));Q->rear = (PCBPtr)malloc(sizeof(PCB));if(!Q->front)exit(0);Q->front->next = NULL;Q->rear->next = NULL;}PCBPtr CreatProcess() //创建进程{PCBPtr process;process = (PCBPtr)malloc(sizeof(PCB));gets(process->pName); //输入进程名srand((unsigned)time(NULL));process->nt = rand() % 10 + 1; //随机生成进程要求运行的时间process->ct = 0; //初始状态已运行时间为0process->priority = rand() % 10 + 1;process->state = 'R'; //进程创建时为就绪状态process->next = NULL;return process;}void Insert(SqQueue *Q,PCB *process)//入队{PCBPtr ptr1,ptr2;if(Q->front->next == NULL) //队空{Q->front->next = Q->rear->next = process;return;}ptr1 = Q->front;ptr2 = ptr1->next;while(ptr1->next != NULL){if(ptr2->priority <= process->priority)//按优先级大小插入一个进程{process->next = ptr2;ptr1->next = process;if(ptr1 == Q->front)Q->front->next = process;break;}else{ptr1 = ptr1->next;ptr2 = ptr1->next;}}if(ptr1->next == NULL)//队尾操作{ptr1->next = process;Q->rear->next = process;process->next = NULL;}}PCBPtr Delete(SqQueue *Q)//删除进程{PCBPtr p;if(Q->front->next == NULL)//为空return NULL;p = Q->front->next;Q->front->next = p->next;if(Q->rear == p)Q->rear = NULL;return p;}void Schedul(SqQueue *Q)//优先级算法{PCBPtr p,ptr;p = Delete(Q);while(p != NULL){puts("----------------------------------------------------------");printf("选中进程名: %s\n",p->pName);p->nt--;//时间和优先级都-1p->priority--;if(p->nt != 0)Insert(Q,p);elsep->state = 'E';//运行时间结束,状态变为“E”ptr = Q->front->next;printf("更新后队列信息:\n ");printf(" 进程名称运行时间优先级状态\n");while(ptr != NULL){printf(" %s %d %d %c\n",ptr->pName,ptr->nt,ptr->priority,ptr->stat e);ptr = ptr->next;}p = Delete(Q);}printf("priority schedul end!\n");}void EnQueue(SqQueue *Q,PCB *process){PCBPtr ptr = Q->rear->next;if(Q->front->next == NULL) //队空{Q->front->next = process;Q->rear->next = process;process->next = Q->front->next; //队尾结点指针指向队首}else{ptr->next = process; //队尾插入一个结点Q->rear->next = process;process->next = Q->front->next; //队尾结点指针指向队首}PCBPtr DeQueue(SqQueue *Q) //出队{PCBPtr p,ptr = Q->rear->next;if(Q->front->next == NULL) //队空return NULL;p = Q->front->next;Q->front->next = p->next;if(Q->rear->next == p) //队中只有一个元素{Q->rear->next = NULL;Q->front->next = NULL;}elseptr->next = Q->front->next;return p;}void robinSchedul(SqQueue *Q){PCBPtr p,ptr;p = DeQueue(Q); //取队首元素while(p != NULL){puts("----------------------------------------------------------");printf("选中进程名: %s\n",p->pName);p->ct++; //运行一个时间片if(p->ct != p->nt) //已运行时间不等于要求运行的时间,则将插入到就绪队列队尾EnQueue(Q,p);elsep->state = 'E'; //已运行时间等于要求运行时间,进行运行结束ptr = Q->front->next;printf("更新后队列信息:\n ");printf(" 进程名称要求运行时间已运行时间优先级状态\n");do{if(ptr == NULL)break;printf(" %s %d %d %d %c\n",ptr->pName,ptr->nt,ptr->ct,p tr->priority,ptr->state);ptr = ptr->next;}while(ptr != Q->front->next);p = DeQueue(Q); //取下一个进程}printf("robinSchedul end!\n");}int main(){int i;int n;char c;PCB *p;PCBPtr ptr;SqQueue Q;InitQueue(&Q);for(;;){switch(menu_select()){case 1:printf("输入进程个数: ");scanf("%d",&n);c = getchar();for(i = 0;i < n;i++){printf("输入进程%d的进程名:",i+1);p = CreatProcess();Insert(&Q,p);}ptr = Q.front->next;printf("进程信息如下:\n");printf(" 进程名称运行时间优先级状态\n");while(ptr != NULL){printf(" %s %d %d %c\n",ptr->pName,ptr->nt,ptr->priority,ptr->state); ptr = ptr->next;}puts("");Schedul(&Q);printf("\t\t\t");system("pause");break;case 2:printf("输入进程个数: ");scanf("%d",&n);c = getchar();for(i = 0;i < n;i++){printf("输入进程%d的进程名:",i+1);p = CreatProcess();EnQueue(&Q,p);}ptr = Q.front->next;printf("进程信息如下:\n");printf(" 进程名称要求运行时间已运行时间状态\n");do{printf(" %s %d %d %c\n",ptr->pName,ptr->nt,ptr->ct,ptr->state);ptr = ptr->next;}while(ptr != Q.front->next);puts("");robinSchedul(&Q);printf("\t\t\t");system("pause");break;case 3:printf("\t\t\t结束退出!\n");printf("\t\t\t");exit(0);}}return 0;}。