操作系统——处理器调度模拟
进程调度模拟算法
进程调度模拟算法进程调度是操作系统中的重要组成部分之一，它负责决定在多道程序环境下，哪个进程将获得CPU的使用权。
进程调度模拟算法是为了研究和评估不同调度策略的性能而开发的一种仿真方法。
在实际系统中，调度算法会受到多种因素的影响，如进程优先级、进程的I/O需求、进程的实际执行时间等。
通过模拟这些因素，可以更好地理解不同调度算法之间的差异，并选择最合适的算法来满足特定需求。
下面介绍两种常见的进程调度模拟算法：先来先服务（FCFS）和最短作业优先（SJF）算法。
1. 先来先服务（FCFS）算法：该算法按照进程到达的顺序来调度任务。
当一个进程完成或阻塞时，下一个已到达的进程将获得CPU的使用权。
这种算法非常简单，但是不适用于长作业时间和短作业时间交替出现的情况。
在短作业启动时，长作业仍然在运行，使得短作业的等待时间增加。
2. 最短作业优先（SJF）算法：该算法根据任务的执行时间来调度进程。
在该算法中，每个进程的执行时间都是已知的，并且操作系统根据已知的执行时间来决定哪个进程获得CPU的使用权。
在短作业优先算法中，短作业将会先被调度，这样有助于减少平均周转时间和等待时间。
但是，短作业优先算法容易产生“饥饿”现象，即长作业可能会一直等待，而短作业一直得到CPU的使用权。
除了以上两种算法，还有其他的进程调度模拟算法。
例如：- 时间片轮转（RR）调度算法：使用固定的时间片来调度进程，当时间片用完后，该进程被放入就绪队列的末尾。
- 优先级调度算法：每个进程都拥有一个优先级，优先级越高的进程越早被调度。
这种方法可以根据不同进程的紧迫程度和重要性来进行调度。
- 多级反馈队列调度算法：将就绪队列划分为多个队列，并根据进程的性质和优先级将进程放入不同的队列。
每个队列都有不同的优先级和时间片大小，进程可以通过提高优先级或时间片大小来提高被调度的机会。
在实际应用中，需要根据系统需求和性能指标选择合适的调度算法。
常用的性能指标包括平均周转时间、平均等待时间、CPU利用率等。
操作系统课程设计报告-进程调度的模拟实现
操作系统课程设计报告专业计算机科学与技术学生姓名班级学号指导教师完成日期博雅学院ﻬ题目:进程调度的模拟实现的模拟实现一、设计目的本课程设计是学习完“操作系统原理”课程后进行的一次全面的综合训练，通过课程设计，更好地掌握操作系统的原理及实现方法，加深对操作系统基础理论和重要算法的理解,加强学生的动手能力。
在多道程序和多任务系统中,系统内同时处于就绪状态的进程可能有若干个。
也就是说能运行的进程数大于处理机个数。
为了使系统中的进程能有条不紊地工作,必须选用某种调度策略，选择一进程占用处理机。
要求学生设计一个模拟处理机调度算法,以巩固和加深处理机调度的概念.二、设计内容1)概述选择一个调度算法，实现处理机调度。
设计要求:１)进程调度算法包括：时间片轮转法，短作业优先算法，动态优先级算法。
2)可选择进程数量3)本程序包括三种算法,用C或Ｃ++语言实现，执行时在主界面选择算法(可用函数实现），进入子页面后输入进程数,（运行时间，优先数由随机函数产生),执行，显示结果。
调度时总是选取优先数最大的进程优先运行２．每个进程的优先数，运行时间，由程序任意指定.3．为了调度方便,把进程按给定优先级(动态优先级算法中）从小到大排成一个队列。
按给定运行时间（短作业优先）从小到大排成一个队列用一个变量作为队首指针,指向队列的第一个进程。
4．处理机调度总是选队首进程运行。
由于本实验是模拟处理机调度，所以被选中的进程并不实际的启动运行，而是执行:优先数－1（动态优先级算法中)要求运行时间－1来模拟进程的一次运行。
5.进程运行一次后，若要求运行时间不等于０,则再将它加入队列（动态优先级算法中:按优先数大小插入.)，且改变队首指针：若要求运行时间=0，则把它的状态改为完成（C)状态,且退出队列。
（5)对于遇到优先数一致的情况,采用FIFO策略解决.3。
概要设计(1)本程序用两种算法对五个进程进行调度,每个进程可有三个状态,并假设初始状态为就绪状态。
计算机操作系统：处理机调度模拟实验
display2(run);
}
p = ready;
if (p != NULL)
printf("\n ****当前就绪队列中进程的状态如下:\n"); /*显示就绪队列状态*/
while (p != NULL)
{
display2(p);
p = p->next;
}
p = finish;
根据单处理机，多任务的问题特性做好软件实现的需求分析。可根据问题的实际需要，可选择进程数量。
当系统运行时，能直观地、动态地反映当前处理机状态及各进程执行的状况。
实验环境
Windows 7或以上版本+ VS2010或以上版本
实验内容
程序运行一次中，要求三个进程队列，每个优先权依次为1、2、3，即优先权为1的只分配1个时间片，优先权为2的只分配2个时间片，优先权为3的只分配3个时间片；每个进程队列命名、进程命名与进程数自定，轮转打印出各个进程名，程序结束打印退出。
run->state = 'R';
display();
}
//探测到有就绪队列时，选择一个将处理机分配给它
void priority(int T)
{
while (run != NULL)
{
run->rtime = run->rtime + T;
run->syቤተ መጻሕፍቲ ባይዱime = run->sytime - T;
实验完成后请现场演示。
实验步骤描述
1.给一系列进程创建结构体
2.写一个printready函数探测就绪队列是否为空
3.写一个display1函数，用于显示当前进程
操作系统中的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算法是一种复杂的算法，它将进程划分为多个队列，分配不同的时间片用于不同的队列。
操作系统实验5 进程调度模拟程序设计
一、实验内容进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）或者时间片轮转法。
每个进程有一个进程控制块（PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
等待I/O的时间以时间片为单位进行计算，可随机产生，也可事先指定。
每个进程的状态可以是就绪R（Ready）、运行R（Run）、等待（Wait）或完成F（Finish）四种状态之一。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、等待进程以及各个进程的PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
用C或C++二、实验目的与要求在采用多道程序设计的设计中的系统中，往往有若干个进程同时处于就绪状态。
当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器本实验模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度工作。
三、实验环境Visual+C++6.0四、实验步骤1、实验准备知识处理器调度总是选对首进程运行。
采用动态改变优先数的办法，进程每运行一次优先数就减“1”。
由于本次实验是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：优先数—1要求运行时间—1来模拟进程的一次运行。
进程运行一次后，若要求运行时间≠0，则再将它加入队列（按优先数大小插入，且置队首标志）；若要求运行时间≠0，则把它的状态修改成“结束”，且结束队列。
操作系统实验报告——调度算法
操作系统实验报告——调度算法1. 实验目的本实验旨在探究操作系统中常用的调度算法，通过编写代码模拟不同的调度算法，了解它们的特点和应用场景。
2. 实验环境本次实验使用的操作系统环境为Linux，并采用C语言进行编码。
3. 实验内容3.1 调度算法1：先来先服务（FCFS）FCFS调度算法是一种简单且常见的调度算法。
该算法按照进程到达的先后顺序进行调度。
在本实验中，我们使用C语言编写代码模拟FCFS算法的调度过程，并记录每个进程的等待时间、周转时间和响应时间。
3.2 调度算法2：最短作业优先（SJF）SJF调度算法是一种非抢占式的调度算法，根据进程的执行时间来选择下一个要执行的进程。
在本实验中，我们使用C语言编写代码模拟SJF算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。
3.3 调度算法3：轮转调度（Round Robin）Round Robin调度算法是一种经典的时间片轮转算法，每个进程在给定的时间片内依次执行一定数量的时间。
如果进程的执行时间超过时间片，进程将被暂时挂起，等待下一次轮转。
在本实验中，我们使用C语言编写代码模拟Round Robin算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。
4. 实验结果分析通过对不同调度算法的模拟实验结果进行分析，可以得出以下结论：- FCFS算法适用于任务到达的先后顺序不重要的场景，但对于执行时间较长的进程可能会导致下一个进程需要等待较久。
- SJF算法适用于任务的执行时间差异较大的场景，能够提高整体执行效率。
- Round Robin算法适用于时间片相对较小的情况，能够公平地为每个进程提供执行时间。
5. 实验总结本次实验通过模拟不同调度算法的实际执行过程，深入了解了各种调度算法的原理、特点和适用场景。
通过对实验结果的分析，我们可以更好地选择合适的调度算法来满足实际应用的需求。
在后续的学习中，我们将进一步探索更多操作系统相关的实验和算法。
操作系统中的CPU调度算法实现与优化
操作系统中的CPU调度算法实现与优化随着计算机技术的不断发展，操作系统作为计算机的重要组成部分已经成为了现代计算机的核心，操作系统的性能对整个计算机的运行和效率有着至关重要的影响。
其中，CPU调度算法是操作系统中的核心内容之一，其对操作系统的性能有着直接的影响作用。
什么是CPU调度算法？CPU调度是操作系统中的一项关键任务，主要负责分配CPU 时间片给各个进程，以实现多进程并发执行。
而CPU调度算法则是CPU调度的关键之一，其主要作用是决定进程在什么情况下能够获取CPU使用权，进程的优先级、时间片大小等等影响着操作系统的性能。
常见的CPU调度算法：1. 先来先服务调度算法（FCFS）先来先服务调度算法，即按照作业到达的先后顺序分配CPU 时间片，每个进程在进入就绪队列后，按照行到达时间先后依次排队等待调度，先到达的进程先分配CPU时间片，然后完成执行后才分配给后续的进程。
这种算法不需要任何额外的参数，其实现简单，但是当进程短任务和长任务交织时，会导致短任务长时间等待，并且也不能满足响应时间的需求。
2. 短作业优先调度算法（SJF）短作业优先调度算法，即根据进程的需要任务量分配CPU时间片，等待时间短的任务优先获取CPU使用权，使得短任务能够更快的得到执行，提高系统的响应速度。
但是，该定调度算法仅适用于批处理系统，当进程数量庞大时，无法快速准确地预估进程的任务量，如果预估不准，就会出现长任务等待短任务的情况。
3. 优先级调度算法优先级调度算法是基于进程的优先级确定分配CPU时间片的方法，一般根据进程的特性，为不同进程设置不同的优先级，每次调度时以优先级高的进程优先获取CPU使用权，直到时间片用完或者进程执行结束。
优先级调度算法有着良好的响应性，但不利于低优先级进程，经常会出现饥饿的情况。
4. 时间片轮转调度算法时间片轮转调度算法指将CPU时间片分成一定长度的时间段，按照进程到达的先后依次分配时间片，等待不同进程请求时间的到达，一旦时间到达，则进行轮换，并将未利用完的时间片赋予下一个进程。
2016___操作系统处理器调度
JCB的主要内容包括： (1)作业情况 (2)资源需求 (3)资源使用情况 （4）作业控制 （5）作业类型
作业调度与进程调度的关系
SPOOLin g作业预 输入 输 入 状 态 预输 入完 成 进程调度 后 备 状 态 就 绪 等 待 完
运 行
成 状 态
SPOOLin g作业缓 输出
作业调度(选 中并创建进程)
作业控制
作业调度(作 业终止并撤离)
3)批作业的调度
(1) 选择作业： (2) 分配资源： (3) 创建进程： (4) 作业控制： (5) 后续处理：
2 交互作业的组织和管理
• 分时系统的作业就是用户的一次上机交互过程， 可认为终端进程的创建是一个交互型作业的开始， 退出命令运行结束代表用户交互型作业的中止。 • 交互作业的情况和资源需求通过操作命令告知系 统，分时用户逐条输入命令，即提交作业（步） 和控制作业运行，系统则逐条执行并给出应答， 每键入一条或一组有关操作命令，便在系统内部 创建一个进程或若干进程来完成相应命令。 • 键盘命令有：作业控制类；资源申请类；文件操 作类；目录操作类；设备控制类等。
响应比定义
响应比 ＝(等待时间 + 要求执行时间) / 要求 执行时间=1+等待时间/要求执行时间 •短作业容易得到较高响应比， •长作业等待时间足够长后，也将获得足 够高的响应比， •饥饿现象不会发生。
HRRF算法举例
四个作业到达系统时间/所需CPU时间:作业1-0/20， 作业2-5/15，作业3-10 /5，作业4- 15/ 10。 • SJF调度顺序为作业1、3、4、2，平均作业周转时 间T=25， 平均带权作业周转时间W=2.25 。 • FCFS调度顺序为作业1、2、3、4，平均作业周转 时 间 T=28.75 ， 平 均 带 权 作 业 周 转 时 间 W=3.125 。 • HRRF 调度顺序为作业 1 、 3 、 2 、 4 ，平均作业周 转 时 间 T=26.25 ， 平 均 带 权 作 业 周 转 时 间 W=2.46 。
操作系统原理第五章处理器调度
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结构外），当有内存空间 时，能很快完成复制工作，但若无内存 空间时，就要在交换区中建立子进程图 象的复本，这时父进程将自己置为创建 状态，以保证自己的图象不被调出内存。
兰州理工大学—操作系统课设—作业调度模拟程序说明书
目录前摘正言 (2)要 (3)文 (4)1.2.3.4.5.6.设计思想 (4)算法用到的主要数据结构（采用类C语言定义） (5)相关的各模块的伪码算法 (5)调试分析 (8)测试结果 (14)源程序（带注释） (15)总结 (24)参考文献 (25)致谢 (26)前言每个用户请求计算机计算的一个计算任务叫做一个作业。
一个作业从输入初始数据到得到计算结果，要经过若干个步骤的相继执行。
例如：编辑、编译、运行等，其中每一个步骤称作一个作业步。
用户向系统提出作业加工步骤的方式称作业控制方式，作业控制方式有两种：终端控制方式（又称直接控制方式或联机控制方式）和批处理控制方式（又称自动控制方式或脱机控制方式）。
在批处理控制方式下，用户采用系统提供的作业控制语言（JCL）写好作业说明书，说明作业加工的步骤。
操作员把一批作业组织成输入流，通过“预输入”手段使每个作业的信息（包括作业说明书、源程序、初始数据等）暂存在辅助存储器的“输入井”中。
批处理多道程序操作系统的作业管理有两个任务：作业调度和作业控制。
采用多道程序设计方法的操作系统，在系统中要经常用保留多个运行的作业，以提高系统效率。
作业调度从系统已接纳的作业分配所需的系统资源。
对被选中运行的作业按照它们各自的作业说明书中规定的步骤进行控制。
摘要对于成批进入系统的作业来说，根据作业控制块信息，按照一定的策略选取若干个作业使它们可以去获得处理器运行，这项工作称为作业调度。
而对于每个用户来说，总希望自己的作业的周转时间尽可能小，最理想的情况是进入系统后能立即运行，即希望作业的周转时间等于执行时间。
对于系统来说，则希望进入系统的作业的平均周转时间尽可能的小，是的CPU的利用率尽量高。
于是，每个计算机系统都必须选择适当的作业调度算法，既考虑用户的要求又要有利于系统效率的提高。
当选中一个作业后，首先要建立此作业的用户进程，同时为其分配系统资源，接着就可以投入运行。
当一个作业执行结束进入完成状态时，负责收回资源，撤销其作业控制块。
操作系统进程调度算法模拟实验
操作系统进程调度算法模拟实验进程调度是操作系统中一个重要的功能，它决定了哪些进程能够获得处理器资源以及如何按照一定的策略来分配这些资源。
为了更好地理解进程调度算法的工作原理，我们可以进行一个模拟实验来观察不同算法的表现效果。
实验设想：我们设想有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. 死锁处理：在多任务处理中，由于各个任务之间资源的竞争，可能会出现死锁的情况。
死锁指的是多个任务因为相互等待对方释放资源而无法继续执行的状态。
操作系统需要设计相应的死锁检测和解除机制，以避免系统陷入死锁状态。
《 操作系统C 》操作系统进程调度模拟
（5）进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态。
（6）进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。
1）、进程添加，如图：
2）、正常运行情况下，如图：
图（1）
3）、发生中断情况下，如图：
4.实验结果分析
在时间按片轮转算法（RR）中，时间片的大小对系统性能有着很大的影响，如果选择很小的时间片将有利于短作业，因为它能较快地完成任务，但会频繁的发生中断、进程上下文的切换，从而增加系统的开销；反之，如果选择太长的时间片，使每个进程都能在一个时间片内完成，时间按片轮转算法（RR）就退化成先来先服务（FCFS）算法了，从而无法满足交互式用户的需求。一个较为可取的大小是，时间片大小略大于一次典型的交互式需要所需求的时间。这样可以使大多数进程在一个时间片内完成。
booleanSusp=false; /*增加进程标志*/
publicRR(){
/*线程*/
myThread=newThread(this);
myThread.start();
/*程序窗口初始化*/
JFrame f=newJFrame();
f.setTitle("时间片轮转调度算法（RR）");
f.setSize(650,450);
if(e.getSource() == jbBegin){
if(Continue==false)
Continue=true;
}
if(e.getSource() == jbAdd){
操作系统 实验一 CPU调度
实验一CPU调度一、实验内容选择一个调度算法，实现处理机调度。
二、实验目的多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些进程优先占用处理机。
本实验模拟实现处理机调度，以加深了解处理机调度的工作。
三、实验题目1、设计一个按优先权调度算法实现处理机调度的程序；2、设计按时间片轮转实现处理机调度的程序。
四、实验要求PCB内容：进程名/PID；要求运行时间（单位时间）；优先权；状态：PCB指针；1、可随机输入若干进程，并按优先权排序；2、从就绪队首选进程运行：优先权-1/要求运行时间-1要求运行时间=0时，撤销该进程3、重新排序，进行下轮调度；4、最好采用图形界面；5、可随时增加进程；6、规定道数，设置后备队列和挂起状态。
若内存中进程少于规定道数，可自动从后备队列调度一作业进入。
被挂起进程入挂起队列，设置解挂功能用于将指定挂起进程解挂入就绪队列。
7、每次调度后，显示各进程状态。
五、实验源码/*** @(#)CPUScheduling.java*** @author Liang Jiabin* @version 1.00 2010/11/5*/import java.awt.*;import javax.swing.*;import java.awt.event.ActionListener;import java.awt.event.ActionEvent;import java.util.Vector;public class CPUScheduling extends Thread{private JFrame frame;private JScrollPane reserveSp,waitingSp,finishSp;private JList reserveList, readyList, waitingList, finishList;private DefaultListModel reserveLm, readyLm, waitingLm, finishLm;private JLabel reserveLbl, readyLbl, CPULbl, waitingLbl, finishLbl;private JTextField CPUTf;private JLabel needTimeLbl, priorityLbl;private JComboBox needTimeCb, priorityCb;private JButton newBtn, suspendBtn, unsuspendBtn, exitBtn;private JLabel rToRLbl,rToCPULbl,CPUToRLbl,CPUToWLbl,wToRLbl;private JLabel CPUToFLbl,warningLbl, explainLbl;private int number = 1; //进程名序号private String CPUProcess = "";private String CPUProcessId = "";private String CPUProcessPriority = "0"; private String CPUProcessTime = "0";private String maxPriorityProcess = "";private String maxPriorityProcessId = ""; private String maxPriorityProcessTime = ""; private String maxPriorityProcessPriority = "0";private Vector waitingReadyV = new Vector(1,1);public CPUScheduling(){frame = new JFrame("CPU Scheduling");Container c = frame.getContentPane();c.setBackground(Color.pink);c.setLayout(null);reserveLbl = new JLabel("后备队列");reserveLbl.setBounds(50,20,60,30);c.add(reserveLbl);reserveLm = new DefaultListModel(); reserveList = new JList(reserveLm);reserveSp = new JScrollPane(reserveList); reserveSp.setBounds(30,50,100,200);c.add(reserveSp);rToRLbl = new JLabel(">>>>>"); rToRLbl.setBounds(145,100,60,30);c.add(rToRLbl);readyLbl = new JLabel("就绪队列"); readyLbl.setBounds(220,20,60,30);c.add(readyLbl);readyLm = new DefaultListModel(); readyList = new JList(readyLm); readyList.setFixedCellHeight(30); readyList.setBounds(200,50,100,200);c.add(readyList);rToCPULbl = new JLabel(">>>>>"); rToCPULbl.setBounds(320,50,50,30);c.add(rToCPULbl);CPUToRLbl = new JLabel("<<<<<"); CPUToRLbl.setBounds(320,65,50,30);c.add(CPUToRLbl);CPULbl = new JLabel("CPU"); CPULbl.setBounds(410,20,50,30);c.add(CPULbl);CPUTf = new JTextField(20); CPUTf.setEditable(false);CPUTf.setBounds(370,55,100,30);c.add(CPUTf);CPUToWLbl = new JLabel("||"); CPUToWLbl.setBounds(415,80,20,50);c.add(CPUToWLbl);wToRLbl = new JLabel("<<<<<"); wToRLbl.setBounds(320,160,50,30);c.add(wToRLbl);waitingLbl = new JLabel("挂起队列"); waitingLbl.setBounds(390,110,60,30);c.add(waitingLbl);waitingLm = new DefaultListModel(); waitingList = new JList(waitingLm);waitingSp = new JScrollPane(waitingList); waitingSp.setBounds(370,140,100,200); c.add(waitingSp);CPUToFLbl = new JLabel(">>>>>"); CPUToFLbl.setBounds(480,55,50,30);c.add(CPUToFLbl);finishLbl = new JLabel("完成队列"); finishLbl.setBounds(560,20,60,30);c.add(finishLbl);finishLm = new DefaultListModel();finishList = new JList(finishLm);finishSp = new JScrollPane(finishList);finishSp.setBounds(540,50,100,200);c.add(finishSp);needTimeLbl = new JLabel("要求运行时间"); needTimeLbl.setBounds(10,330,100,30);c.add(needTimeLbl);String[] time = {"1","2","3","4","5","6","7","8","9"}; needTimeCb = new JComboBox(time); needTimeCb.setEditable(true);needTimeCb.setBounds(95,330,60,30);c.add(needTimeCb);priorityLbl = new JLabel("优先权");priorityLbl.setBounds(175,330,50,30);c.add(priorityLbl);String[] priority = {"1","2","3","4","5","6","7","8","9"}; priorityCb = new JComboBox(priority);priorityCb.setBounds(220,330,60,30);c.add(priorityCb);newBtn = new JButton("增加");newBtn.setBounds(120,380,60,30);c.add(newBtn);warningLbl = new JLabel();warningLbl.setForeground(Color.RED);warningLbl.setBounds(360,350,200,30);c.add(warningLbl);suspendBtn = new JButton("挂起");suspendBtn.setBounds(340,380,60,30);c.add(suspendBtn);unsuspendBtn = new JButton("解挂");unsuspendBtn.setBounds(440,380,60,30);c.add(unsuspendBtn);exitBtn = new JButton("退出");exitBtn.setBounds(560,380,60,30);c.add(exitBtn);explainLbl = new JLabel("注：进程信息表示为“进程名，需要运行时间，优先权”");explainLbl.setBounds(10,420,500,30);c.add(explainLbl);//Button事件注册ButtonListener btnListener = new ButtonListener();newBtn.addActionListener(btnListener);suspendBtn.addActionListener(btnListener);unsuspendBtn.addActionListener(btnListener);exitBtn.addActionListener(btnListener);//调度器线程开启this.start();frame.setSize(720,520);frame.setVisible(true);frame.setLocationRelativeTo(null);frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);}/** 开启线程*/public synchronized void run(){try{while (true){//判断waiting队列是否有进程在等待进ready队列while (readyLm.size()<4 && waitingReadyV.size() != 0){String s = waitingReadyV.get(0).toString();readyLm.addElement(s);wToRLbl.setForeground(Color.RED);this.sleep(500);wToRLbl.setForeground(Color.BLACK);waitingReadyV.remove(0);waitingLm.removeElement(s);}//判断后备队列进程能否进就绪队列while (readyLm.size()<4 && !reserveLm.isEmpty()){readyLm.addElement(reserveLm.getElementAt(0));rToRLbl.setForeground(Color.RED);this.sleep(500);rToRLbl.setForeground(Color.BLACK);reserveLm.removeElementAt(0);}//对就绪队列中的进程按优先级排序，找出优先级最大的进入CPU运行if (!readyLm.isEmpty()){String[] s;int index = -1;for (int i=readyLm.size()-1; i>=0; i--){s = readyLm.getElementAt(i).toString().split(",");if (Integer.parseInt(s[2]) >= Integer.parseInt(CPUProcessPriority)){maxPriorityProcess = readyLm.getElementAt(i).toString();maxPriorityProcessId = s[0];maxPriorityProcessTime = s[1];maxPriorityProcessPriority = s[2];index = i;CPUProcessPriority = maxPriorityProcessPriority;}}if (!maxPriorityProcessId.equals(CPUProcessId)){CPUProcess = maxPriorityProcess;CPUProcessId = maxPriorityProcessId;CPUProcessTime = maxPriorityProcessTime;CPUProcessPriority = maxPriorityProcessPriority;}rToCPULbl.setForeground(Color.RED);CPUTf.setText(CPUProcessId);this.sleep(500);readyLm.removeElement(CPUProcess);rToCPULbl.setForeground(Color.BLACK);}this.sleep(1000); //在CPU上运行一秒//时间片到了，CPU上的进程转到就绪队列或完成队列if (!CPUTf.getText().equals("")){CPUTf.setText("");int time = Integer.parseInt(CPUProcessTime);CPUProcessTime = String.valueOf(--time);if (Integer.parseInt(CPUProcessPriority) > 1) //若优先级不为1则减1{int priority = Integer.parseInt(CPUProcessPriority);CPUProcessPriority = String.valueOf(--priority);}if (Integer.parseInt(CPUProcessTime) != 0) //要求运行时间不为0则进入ready队列{CPUProcess = CPUProcessId + "," + CPUProcessTime + "," + CPUProcessPriority;readyLm.addElement(CPUProcess);CPUToRLbl.setForeground(Color.RED);this.sleep(500);CPUTf.setText("");CPUToRLbl.setForeground(Color.BLACK);}else //要求运行时间为0则转到完成队列{CPUToFLbl.setForeground(Color.RED);CPUProcessTime = String.valueOf(0);CPUProcessPriority = String.valueOf(0);CPUProcess = CPUProcessId + "," + CPUProcessTime + "," + CPUProcessPriority;finishLm.addElement(CPUProcess);CPUProcessId = "";this.sleep(500);CPUToFLbl.setForeground(Color.BLACK);}}}}catch (Exception e){e.printStackTrace();}}/** 按钮监听器*/class ButtonListener implements ActionListener{public synchronized void actionPerformed(ActionEvent ae) {JButton source = (JButton)ae.getSource();if (source == newBtn) //增加进程{String time = "1";time = needTimeCb.getSelectedItem().toString();String priority = "1";priority = priorityCb.getSelectedItem().toString();String pid = String.valueOf(number);String reserveItem = "";reserveItem = "P" + pid + "," + time + "," + priority;reserveLm.addElement(reserveItem);number++;}else if (source == suspendBtn) //挂起进程{System.out.println("点击挂起" ); /////if (!CPUTf.getText().equals("")){CPUToWLbl.setForeground(Color.RED);CPUTf.setText("");CPUProcessId = "";waitingLm.addElement(CPUProcess);System.out.println("挂起成功" ); /////try{sleep(500);}catch (Exception e){}CPUToWLbl.setForeground(Color.BLACK);}}else if (source == unsuspendBtn) //解挂进程{System.out.println("点击解挂" ); /////String unsuspendProcess = "";if (waitingList.getSelectedValue()!= null){unsuspendProcess = waitingList.getSelectedValue().toString();waitingReadyV.add(unsuspendProcess);warningLbl.setText("");System.out.println("解挂成功" ); /////}else{warningLbl.setText("请选要择解挂的进程");}}else if (source == exitBtn) //退出程序{System.exit(0);}}}/** main函数*/public static void main(String args[]){new CPUScheduling();}}六、实验结果。
操作系统-CPU调度
操作系统-CPU调度CPU调度 (CPU scheduling)：多个进程同时处于内存，当⼀个进程必须等待时，OS从该进程拿⾛CPU使⽤权交给其他进程。
进程执⾏从⼀个IO区间(I/O burst)开始，随后进⼊⼀个CPU区间(CPU burst)并反复，进程循环地在CPU执⾏和I/O等待两个状态间切换，直到通过系统请求终⽌最后⼀个CPU burst。
CPU burst的长度随进程和计算机的不同⽽变化，通常具有⼤量短CPU burst和少量长CPU burst。
I/O约束程序通常具有很多短CPU burst，CPU约束程序可能有少量长CPU burst。
每当CPU空闲时，OS就使⽤短期调度程序(short-term scheduler) （或CPU scheduler）从就绪队列中选择⼀个能够执⾏的进程并为它分配CPU。
就绪队列不⼀定是FIFO队列。
就绪队列中的记录通常为PCB。
抢占&⾮抢占CPU调度决策发⽣在4种情况下：1) 进程从运⾏(running)状态切换到等待(waiting)状态；2) 进程从运⾏(running)状态切换到就绪(ready)状态；3) 进程从等待(waiting)状态切换到就绪(ready)状态；4) 进程终⽌⾮抢占(nonpreemptive)调度⽅案：a.k.a. 协作(cooperative)调度⽅案，⼀旦CPU分配给⼀个进程，该进程会⼀直使⽤CPU直到进程终⽌或切换到等待状态，该⽅案中调度只发⽣在1、4两种情况下。
否则称为抢占(preemptive)调度⽅案。
分派程序分派程序(dispatcher)：每次进程切换时都要使⽤的⼀个模块，⽤于将CPU控制交给由short-term scheduler 所选的进程。
功能包括1)切换上下⽂；2)切换到⽤户模式；3)跳转⽤户程序的合适位置来重启程序。
分派延迟(dispatch latency)：dispatcher停⽌⼀个进程并启动另⼀个进程所⽤的时间。
进程调度模拟程序实验实验报告
进程调度模拟程序实验实验报告一、实验目的进程调度是操作系统的核心功能之一，它负责合理地分配 CPU 资源给各个进程，以提高系统的性能和效率。
本次实验的目的是通过编写和模拟进程调度程序，深入理解不同的进程调度算法的原理和特点，并比较它们在不同情况下的性能表现。
二、实验环境本次实验使用的编程语言为 Python，开发环境为 PyCharm。
操作系统为 Windows 10。
三、实验原理1、先来先服务（FCFS）调度算法先来先服务调度算法按照进程到达的先后顺序进行调度，先到达的进程先获得 CPU 资源。
2、短作业优先（SJF）调度算法短作业优先调度算法优先调度执行时间短的进程。
3、时间片轮转（RR）调度算法时间片轮转调度算法将 CPU 时间划分为固定大小的时间片，每个进程轮流获得一个时间片的 CPU 资源。
四、实验设计1、进程类的设计创建一个进程类，包含进程 ID、到达时间、服务时间、剩余服务时间等属性，以及用于更新剩余服务时间和判断进程是否完成的方法。
2、调度算法实现分别实现先来先服务、短作业优先和时间片轮转三种调度算法。
3、模拟流程（1）初始化进程列表。
（2）按照选定的调度算法进行进程调度。
（3）计算每个进程的等待时间、周转时间等性能指标。
五、实验步骤1、定义进程类｀｀｀pythonclass Process:def ＿_init__(self, pid, arrival_time, service_time)：selfpid ＝ pidselfarrival_time ＝ arrival_timeselfservice_time ＝ service_timeselfremaining_service_time ＝ service_time｀｀｀2、先来先服务调度算法实现｀｀｀pythondef fcfs_scheduling(process_list)：current_time ＝ 0total_waiting_time ＝ 0total_turnaround_time ＝ 0for process in process_list:if current_time ＜ processarrival_time:current_time ＝ processarrival_timewaiting_time ＝ current_time processarrival_timetotal_waiting_time ＋＝ waiting_timecurrent_time ＋＝ processservice_timeturnaround_time ＝ current_time processarrival_timetotal_turnaround_time ＋＝ turnaround_timeaverage_waiting_time ＝ total_waiting_time ／ len(process_list)average_turnaround_time ＝ total_turnaround_time ／ len(process_list) print(＂先来先服务调度算法的平均等待时间：＂，average_waiting_time)print(＂先来先服务调度算法的平均周转时间：＂，average_turnaround_time)｀｀｀3、短作业优先调度算法实现｀｀｀pythondef sjf_scheduling(process_list)：current_time ＝ 0total_waiting_time ＝ 0total_turnaround_time ＝ 0sorted_process_list ＝ sorted(process_list, key=lambda x: xservice_time) for process in sorted_process_list:if current_time ＜ processarrival_time:current_time ＝ processarrival_timewaiting_time ＝ current_time processarrival_timetotal_waiting_time ＋＝ waiting_timecurrent_time ＋＝ processservice_timeturnaround_time ＝ current_time processarrival_timetotal_turnaround_time ＋＝ turnaround_timeaverage_waiting_time ＝ total_waiting_time ／ len(process_list)average_turnaround_time ＝ total_turnaround_time ／ len(process_list) print(＂短作业优先调度算法的平均等待时间：＂，average_waiting_time)print(＂短作业优先调度算法的平均周转时间：＂，average_turnaround_time)｀｀｀4、时间片轮转调度算法实现｀｀｀pythondef rr_scheduling(process_list, time_slice)：current_time ＝ 0total_waiting_time ＝ 0total_turnaround_time ＝ 0ready_queue ＝while len(process_list) ＞ 0 or len(ready_queue) ＞ 0:for process in process_list:if processarrival_time ＜＝ current_time:ready_queueappend(process)process_listremove(process)if len(ready_queue) ＝＝ 0:current_time ＋＝ 1continueprocess ＝ ready_queuepop(0)if processremaining_service_time ＜＝ time_slice: waiting_time ＝ current_time processarrival_time total_waiting_time ＋＝ waiting_timecurrent_time ＋＝ processremaining_service_time turnaround_time ＝ current_time processarrival_time total_turnaround_time ＋＝ turnaround_time processremaining_service_time ＝ 0else:waiting_time ＝ current_time processarrival_time total_waiting_time ＋＝ waiting_timecurrent_time ＋＝ time_sliceprocessremaining_service_time ＝ time_sliceready_queueappend(process)average_waiting_time ＝ total_waiting_time ／ len(process_list)average_turnaround_time ＝ total_turnaround_time ／ len(process_list) print(＂时间片轮转调度算法（时间片大小为"， time_slice, ＂）的平均等待时间：＂， average_waiting_time)print(＂时间片轮转调度算法（时间片大小为"， time_slice, ＂）的平均周转时间：＂， average_turnaround_time)｀｀｀5、主函数｀｀｀pythonif ＿_name__ ＝＝＂＿_main__"：process_list ＝Process(1, 0, 5)，Process(2, 1, 3)，Process(3, 2, 8)，Process(4, 3, 6)print(＂先来先服务调度算法：＂）fcfs_scheduling(process_list)print(＂短作业优先调度算法：＂）sjf_scheduling(process_list)time_slice ＝ 2print(＂时间片轮转调度算法（时间片大小为"，time_slice, ＂）：＂）rr_scheduling(process_list, time_slice)｀｀｀六、实验结果与分析1、先来先服务调度算法平均等待时间为 575，平均周转时间为 1275。
操作系统进程调度模拟算法附源码
先来先服务（FCFS）
定义：按照进程到 达的先后顺序进行 调度
优点：实现简单， 适用于CPU繁忙型 进程
缺点：等待时间较 长，可能导致饥饿 现象
适用场景：适用于 CPU密集型进程， 不适用于I/O密集 型进程
最短作业优先（SJF）
定义：按照作业的估计运行时间进行排序，选择最短作业优先执行 优点：响应时间快，作业平均等待时间少 缺点：存在饥饿现象，长作业可能长时间得不到执行 适用场景：适用于作业量较大且作业到达时间间隔较长的情况
Part Five
模拟实验结果及分 析
实验环境及参数设置
处理器：Intel Core i78700K
操作系统：Linux
内存：16GB DDR4 硬盘：256GB SSD
实验结果展示
实验数据：模拟算法在不同情况下的运行结果 数据分析：对实验数据进行分析，得出结论 结果对比：将模拟算法与实际操作系统进行对比，分析差异 结果展示：以图表、表格等形式展示实验结果
优先级调度算法
定义：根据进 程的优先级进 行调度，优先 级高的进程优 先获得处理器
资源
分类：静态优 先级调度算法 和动态优先级
调度算法
静态优先级调 度算法：优先 级在进程创建 时就确定，且 在运行过程中
保持不变
动态优先级调 度算法：优先 级根据进程的 行为和需求动
态调整
轮转法（RR）
定义：轮转法是 一种简单且常用 的进程调度算法， 也称为循环调度
算法。
原理：按照进程 到达的先后顺序， 按照固定的时间 片进行循环调度。
特点：每个进程 分配一个固定时 间片，时间片用 完后自动切换到 下一个进程，如 果时间片未用完， 则一直运行直到
实验一___处理器调度(设计一个按时间片轮转法实现处理器调度的程序)介绍
实验一处理器调度一、实验内容选择一个调度算法，实现处理器调度。
二、实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。
当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。
本实习模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。
三、实验题目第二题：设计一个按时间片轮转法实现处理器调度的程序。
[提示]：(1)假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。
进程控制块的格式为：其中，Q1，Q2，Q3，Q4，Q5。
指针——进程按顺序排成循环队列，用指针指出下一个进程的进程控制块的首地址最后一个进程的指针指出第一个进程的进程控制块首地址。
要求运行时间——假设进程需要运行的单位时间数。
已运行时间——假设进程已经运行的单位时间数，初始值为“0”。
状态——有两种状态，“就绪”和“结束”，初始状态都为“就绪”，用“R”表示。
当一个进程运行结束后，它的状态为“结束”，用“E”表示。
(2) 每次运行所设计的处理器调度程序前，为每个进程任意确定它的“要求运行时间”。
(3) 把五个进程按顺序排成循环队列，用指针指出队列连接情况。
另用一标志单元记录轮到运行的进程。
例如，当前轮到P2执行，则有：标志单元K1K2K3K4K5PCB1 PCB2 PCB3 PCB4 PCB5(4)处理器调度总是选择标志单元指示的进程运行。
由于本实习是模拟处理器调度的功能，所以，对被选中的进程并不实际的启动运行，而是执行：已运行时间+1来模拟进程的一次运行，表示进程已经运行过一个单位的时间。
请同学注意：在实际的系统中，当一个进程被选中运行时，必须置上该进程可以运行的时间片值，以及恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行满一个时间片。
在这时省去了这些工作，仅用“已运行时间+1”来表示进程已经运行满一个时间片。
(5)进程运行一次后，应把该进程的进程控制块中的指针值送到标志单元，以指示下一个轮到运行的进程。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
progress p[5];
for(i=0;i<5;i++)
{
cout<<"请输入进程"<<i+1<<"的值"<<endl;
cout<<"请输入进程名"<<endl;
cin>>name;
cout<<"请输入运行时间"<<endl;
cin>how1()
{
cout<<"进程名"<<name<<" ";
cout<<"运行时间"<<time<<" ";
cout<<"优先数"<<pno<<endl;
pno--;
time--;
if(time==0)
state=0;
}
void show2()
#include "stdafx.h"
#include<iostream>
using namespace std;
class progress
{
private:
char name;
int time;
int pno;
int state;
public:
progress()
cout<<"请输入优先数"<<endl;
cin>>pno;
p[i].getprogress(name,time,pno);
}
int j=5;
while(j>0)
{
cout<<"结果："<<endl;
int t=0;
for(i=1;i<5;i++)
{
if(state!=0)
{
cout<<"进程名"<<name<<" ";
cout<<"运行时间"<<time<<" ";
cout<<"优先数"<<pno<<endl;
}
}
};
void main()
{
int i;
char name;
{
j--;
}
}
if(j!=0)
j=5;
}
}
{
state=1;
}
void getprogress(char n,int t,int p)
{
name=n;
time=t;
pno=p;
}
int getp()
{
return pno;
}
int gets()
{
return state;
{
if(p[t].getp()<p[i].getp())
t=i;
}
p[t].show1();
for(i=0;i<5;i++)
{
if(i!=t)
p[i].show2();
}
for(i=0;i<5;i++)
{
if(p[i].gets()==0)