进程调度算法模拟带答案版.pptx
操作系统-进程调度模拟算法(附源码)
进程调度模拟算法课程名称：计算机操作系统班级：信1501-2实验者姓名：李琛实验日期：2018年5月1日评分：教师签名：一、实验目的进程调度是处理机管理的核心内容。
本实验要求用高级语言编写模拟进程调度程序，以便加深理解有关进程控制快、进程队列等概念，并体会和了解优先数算法和时间片轮转算法的具体实施办法。
二、实验要求1.设计进程控制块 PCB 的结构，通常应包括如下信息：进程名、进程优先数（或轮转时间片数）、进程已占用的 CPU 时间、进程到完成还需要的时间、进程的状态、当前队列指针等。
2.编写两种调度算法程序：优先数调度算法程序循环轮转调度算法程序3.按要求输出结果。
三、实验过程分别用两种调度算法对伍个进程进行调度。
每个进程可有三种状态；执行状态（RUN）、就绪状态（READY,包括等待状态）和完成状态（FINISH），并假定初始状态为就绪状态。
（一）进程控制块结构如下：NAME——进程标示符PRIO/ROUND——进程优先数/进程每次轮转的时间片数（设为常数 2）CPUTIME——进程累计占用 CPU 的时间片数NEEDTIME——进程到完成还需要的时间片数STATE——进程状态NEXT——链指针注：1.为了便于处理，程序中进程的的运行时间以时间片为单位进行计算；2.各进程的优先数或轮转时间片数，以及进程运行时间片数的初值，均由用户在程序运行时给定。
（二）进程的就绪态和等待态均为链表结构，共有四个指针如下：RUN——当前运行进程指针READY——就需队列头指针TAIL——就需队列尾指针FINISH——完成队列头指针（三）程序说明1. 在优先数算法中，进程优先数的初值设为：50-NEEDTIME每执行一次，优先数减 1，CPU 时间片数加 1，进程还需要的时间片数减 1。
在轮转法中，采用固定时间片单位（两个时间片为一个单位），进程每轮转一次，CPU时间片数加 2，进程还需要的时间片数减 2，并退出 CPU，排到就绪队列尾，等待下一次调度。
进程调度算法模拟
操作系统实验报告姓名：班级：学号：指导教师：实验一进程调度算法模拟，用动态优先数及时间片轮转法实现进程调度一．实验内容：设计一个简单的进程调度算法，模拟OS中的进程调度过程二．实验要求：①进程数不少于5个；②进程调度算法任选；最好选用动态优先数法，每运行一个时间片优先数减3③用C++（或C）语言编程；④程序运行时显示进程调度过程。
三．实验步骤：①设计PCB及其数据结构：struct pcb{ /* 定义进程控制块PCB */char name[10];char state;int super;int ntime;int rtime;struct pcb* link;} *ready=NULL,*p;typedef struct pcb PCB;②设计进程就绪队列及数据结构；三个应用队列：PCB *ready=NULL,*run=NULL,*finish=NULL;③设计进程调度算法，并画出程序流程图；④设计输入数据和输出格式；结构格式：当前正运行的进程：0当前就绪队列：2，1，3，4⑤编程上机，验证结果。
源程序代码如下：#include<stdio.h>void main(){int a[4][5]={{0,1,2,3,4},{9,38,30,29,0},{0,0,0,0,0},{3,3,6,3,4}};int a1[5],a0[5],a2[5],num;printf("当前系统中有5个进程，其初始状态如下：\n\n");for(int i=0;i<4;i++){if(i==0)printf("ID ");if(i==1)printf("PRIORITY ");if(i==2)printf("CPUTIME ");if(i==3)printf("ALLTIME ");for(int j=0;j<5;j++){printf("%5d ",a[i][j]);}printf("\n");}printf("STATE ready ready ready ready ready");for(;;){for(i=0;i<5;i++){a0[i]=a[1][i];}for(i=0;i<5;i++){for(int j=0;j<5-1;j++){if(a0[j]<=a0[j+1]){num=a0[j];a0[j]=a0[j+1];a0[j+1]=num;}}}//a0数组为排列好的优先极for(int j=0;j<5;j++){a2[j]=a[1][j];}for(i=0;i<5;i++){for(int j=0;j<5;j++){if(a0[i]==a2[j]){a1[i]=j;a2[j]=-10;break;}}}a[1][a1[0]]-=3;a[2][a1[0]]+=1;a[3][a1[0]]-=1;printf("\n");if(a[3][a1[0]]<=0){a[1][a1[0]]=-3;}int ji=0;for(i=0;i<5;i++){ji+=a[3][i];}printf("\n当前运行程序为：%d\n当前就绪队列：",a1[0]);for(i=1;i<5;i++){if(a[1][a1[i]]>=0)printf("%d ",a1[i]);}if(ji<=0)break;printf("\n\n程序正在运行中...");}printf("\n\n当前程序已全部运行完毕\n");}实验结果：四．实验总结：（1）本次试验后对优先数调度算法和时间片轮转调度算法实现的过程，有了很清楚的认识、理解。
操作系统进程调度算法的模拟
操作系统进程调度算法的模拟其次，我们来介绍短作业优先（Shortest Job Next，SJN）算法。
SJN算法按照任务的运行时间来决定运行顺序，即先运行运行时间最短的进程。
该算法能够最大程度地减少平均等待时间，但对于长任务可能导致长时间的等待。
接下来，我们介绍轮转（Round Robin，RR）算法。
RR算法是一种基于时间片的调度算法，将CPU分为若干个时间片，并依次分配给各个进程。
当一个进程的时间片用完后，将其放入队列尾部，继续运行下一个进程。
该算法具有公平性和响应性较高的特点，但对于长时间运行的进程，可能会导致较大的上下文切换开销。
此外，还有最高响应比优先（Highest Response Ratio Next，HRRN）算法。
HRRN算法通过计算等待时间和服务时间的比例来决定运行顺序，即选取响应比最高的进程先执行。
该算法能够尽可能减少平均响应时间，但对于长任务可能存在运行时间过长的问题。
最后，我们介绍最短剩余时间优先（Shortest Remaining Time First，SRTF）算法。
SRTF算法是SJN算法的抢占版本，当有新进程到达时，会比较其剩余运行时间与当前运行进程的时间，如果新进程的剩余时间较短，则立即进行进程切换。
该算法能够最大程度地减少平均等待时间和响应时间，但对于切换开销较大。
针对这几种进程调度算法，我们可以通过编写模拟程序来验证其性能和特点。
首先，我们需要定义进程的数据结构，包括进程ID、到达时间、服务时间等属性。
然后，我们可以编写一个模拟函数来按照不同的算法进行调度，并统计平均等待时间、平均响应时间、吞吐量等指标。
通过对比不同算法在不同场景下的表现，可以评估其优劣。
总结起来，不同的进程调度算法有着各自的优缺点，根据实际需求选择合适的算法能够提高系统的性能和用户体验。
通过模拟和评估这些算法，我们可以更好地理解其原理和适用范围，并为实际系统的设计和优化提供参考。
希望这篇文章能够帮助你更好地理解和应用进程调度算法。
第七讲 进程调度ppt
低级调度
• 进程调度、短程调度。 进程调度、短程调度。 • 主要功能是按照某种原则决定就绪队 列中的哪个进程或内核级线程能获得 处理器, 处理器, 并将处理机出让给它进行工 作。 • 短程调度程序是操作系统最为核心的 部分， 部分，短程调度策略的优劣直接影响 到整个系统的性能。 到整个系统的性能。
进程调度要解决的问题
WHAT：按什么原则分配CPU WHAT：按什么原则分配CPU —进程调度算法 进程调度算法 WHEN：何时分配CPU WHEN：何时分配CPU —进程调度的时机 进程调度的时机 HOW： 如何分配CPU HOW： 如何分配CPU —进程调度过程（进程的切换） 进程调度过程（ 进程调度过程 进程的切换）
平均作业周转时间
• 为了提高系统的性能 ， 要让若干个 为了提高系统的性能， 用户的平均作业周转时间和平均带 权周转时间最小。 权周转时间最小。 平均作业周转时间 T = (Σti) / n
作业带权周转时间和平均作业带权周转时间
• 如果作业 i 的周转时间为 ti ， 所需运行时 如果作业i 的周转时间为t 间为t 则称w 间为tk，则称wi=ti /tk为该作业的带权周 转时间。 转时间。 • ti是等待时间与运行时间之和，故带权周 是等待时间与运行时间之和， 转时间总大于1 转时间总大于1。 平均作业带权周转时间W = (Σwi) / n
28+37+40)/ )/3 T = (28+37+40)/3 = 35
先来先服务算法(3) 先来先服务算法(3)
•若三个作业提交顺序改为作业2、 1、3，平均作业周转时间约为29。 •若三个作业提交顺序改为作业3、 2、1，平均作业周转时间约为18。 FCFS调度算法的平均作业周转时间 与作业提交的顺序有关。
操作系统进程调度算法模拟实验
操作系统进程调度算法模拟实验进程调度是操作系统中一个重要的功能，它决定了哪些进程能够获得处理器资源以及如何按照一定的策略来分配这些资源。
为了更好地理解进程调度算法的工作原理，我们可以进行一个模拟实验来观察不同算法的表现效果。
实验设想：我们设想有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。
操作系统进程调度算法优秀课件
为 CPU 的执行设定一个时间片大小，每个进程 轮询分配时间片，时间片结束后暂停运行加入等 待队列 时间片不能选择太长，否则退化为FCFS
多级反馈队列
不必事先知道进程所需要的执行时间，还可以较 好地满足各种类型进程的需要 多个就绪队列，赋予不同优先级 每个队列采用FCFS，按队列优先级调度
4
开发环境
Contents
1 题目理解 title 2 开发环境 title 3 主要功能 title 4 设计思路 title
1
题目理解
在Linux或Windows环境下编程模拟实现进程调 度，包括：先来先服务，时间片轮转，优先级， 多级反馈队列等进程调度算法。
2
FCFS先来先服务
这是最简单，最基本的算法，就是按照进程到来的时间 顺序，逐个分配 CPU 资源 优点：简单，方便 缺点：效率低，资源利用率低
8
设计思路
• 模块设计： （共同设计部分） M_interface.java——实现了主界面设计和调用三种算法模拟子界面（共用） （个人设计部分） A_interface.java——实现调用子界面 A_process.java——进程类，利用了链表的数据结构 A_fcfs.java——先来先服务算法的实现 A_rr.java——时间片轮转调度算法的实现 A_psa.java——优先级调度算法的实现 A_mfq.java——多级反馈队列调度算法的实现
6
需要运行时间
进程的运行时间以时间片为单位进行计算 就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1 来表示。
如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行 时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未 达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先 数减1（即降低一级），然后把它插入就绪队列等待CPU。
实验一 进程调度模拟算法
实验一进程调度模拟算法
进程调度模拟算法是操作系统中的重要概念，它是指操作系统如何安排进程的执行顺序，以达到最优的系统性能。
常见的进程调度算法包括先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR）等。
下面将分别介绍这些算法的原理和特点。
1. 先来先服务（FCFS）
先来先服务是最简单的进程调度算法，它按照进程到达的先后顺序进行调度，即先到达的进程先执行。
这种算法的优点是实现简单，适用于长作业，但是它存在一个致命的缺陷，即无法处理短作业的情况，因为长作业可能会占用大量的CPU 时间，导致短作业等待时间过长。
2. 短作业优先（SJF）
短作业优先是一种非抢占式的调度算法，它按照进程的执行时间长短进行调度，即执行时间短的进程先执行。
这种算法的优点是可以减少平均等待时间，但是它存在一个问题，即可能会导致长作业一直等待，因为短作业总是可以插队执行。
3. 时间片轮转（RR）
时间片轮转是一种抢占式的调度算法，它将CPU时间划分为若干个时间片，每个进程在一个时间片内执行一定的时间，然后被挂起，让其他进程执行，直到所有进程都执行完毕。
这种算法的优点是可以保证所有进程都能得到执行，但是它存在一个问题，即时间片的长度会影响系统性能，如果时间片太短，会增加上下文切换的开销，如果时间片太长，会导致长作业等待时间过长。
实验一介绍了三种常见的进程调度算法，它们各有优缺点，需要根据具体的应用场景选择合适的算法。
操作系统进程调度算法模拟
实验一进程调度算法模拟一.实验题目：设计一个简单的进程调度算法，模拟OS中的进程调度过程二．要求：①进程数不少于5个；②进程调度算法任选；可以用动态优先数加时间片轮转法实现进程调度，每运行一个时间片优先数减3；③用C语言编程；④程序运行时显示进程调度过程。
三．程序中所用数据结构及说明:进程控制块结构体：typedef struct node1{int ID;//进程标识数int PRIORITY;//进程优先数int CPUTIME;//进程已占用时间片int ALLTIME;//进程还需占用时间片}Block,pcb;就绪进程链表节点：typedef struct node2{pcb data;struct node2 *next;}process;四．清单程序及描述：Procelink.h:typedef struct node1{int ID;//进程标识数int PRIORITY;//进程优先数int CPUTIME;//进程已占用时间片int ALLTIME;//进程还需占用时间片//char STATE;//进程状态//struct node *next;//进程队列指针}Block,pcb;typedef struct node2{pcb data;struct node2 *next;}process;void Initlink(process **PQ){/*如果有内存空间，申请头结点空间并使头指针head指向头结点*/if((*PQ = (process *)malloc(sizeof(process))) == NULL) exit(1);(*PQ)->next = NULL; /*置链尾标记NULL */}int IsEmpty(process *PQ){if(PQ->next == NULL)return 1;else return 0;}void EnInitlink(process *PQ,pcb p){while(PQ->next!=NULL) PQ=PQ->next;process *temp=(process *)malloc(sizeof(Block));temp->data.PRIORITY=p.PRIORITY;temp->data.ID=p.ID;temp->data.CPUTIME=p.CPUTIME;temp->data.ALLTIME=p.ALLTIME;temp->next=PQ->next;PQ->next=temp;}//插入pcb DeInitlink(process *PQ) //选择优先数最小的出列{if(IsEmpty(PQ)){printf("所有进程已运行完!\n");exit(0);//退出}process *temp=(process *)malloc(sizeof(Block));temp = PQ->next;process *te=(process *)malloc(sizeof(Block));process *t=(process *)malloc(sizeof(Block));te= PQ->next;//优先数最小的进程while(temp->next != NULL){if(te->data.PRIORITY<temp->next->data.PRIORITY){te=temp->next;t=temp->next->next;PQ=temp;}temp=temp->next;}PQ->next=PQ->next->next;pcb pp=te->data;// free(temp);// free(t);//free(te);return pp;}//出队列void outid(process *PQ)//输出就绪队列函数{ printf("当前就绪队列为: ");while(!IsEmpty(PQ)){printf("%d ",PQ->next->data.ID);PQ=PQ->next;}printf("\n");}void dispatch(pcb p,process *PQ)//进程运行函数{if((p.ALLTIME)!=0){p.PRIORITY-=3;p.CPUTIME+=1;p.ALLTIME-=1;printf("进程%d运行\n",p.ID);//printf("进程优先数：%d 进程已占用时间片：%d 进程还需占用时间片：%d\n",p.PRIORITY,p.CPUTIME,p.ALLTIME);outid(PQ);//输出就绪队列}if((p.ALLTIME)==0){printf("进程%d 运行完成!\n",p.ID);return;//完成则不加入链表}EnInitlink(PQ,p); return;//运行之后再加入链表}os_1.cpp:#include<stdio.h>#include<stdlib.h>#include"procelink.h"void main(){process * PQ;int n;//n为进程数pcb pro1;Initlink(& PQ);printf("请输入进程个数：");scanf("%d",&n);printf("请输入各个进程的进程标识数ID,进程优先数，进程已占用时间片，进程还需占用时间片\n");for(int i=1;i<=n;i++){printf("第%d进程: ",i);scanf("%d %d %d %d",&pro1.ID,&pro1.PRIORITY,&pro1.CPUTIME,&pro1.ALLTIME);EnInitlink(PQ,pro1);}while(!IsEmpty(PQ)){dispatch(DeInitlink(PQ),PQ);//进程运行函数调用}if(IsEmpty(PQ))printf("所有进程已运行完!\n");free(PQ);//释放内存空间}五．执行结果：六．实验总结：通过这次操作系统中进程调度算法的模拟，使我对操作系统中的进程调度有了更清晰的认识和了解，程序中也有不足之处，该程序是顺序进链，出链时再选择优先数最大的进程。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
int i=0,j; int number_schedul,temp_counter; /*正在被调度执行的进程编号和已经调度完成的进程个数*/ float run_time; /*借助该局部变量可以帮助找到执行时间 run_time 最短进程*/ run_time=tasks[i].run_time; j=1; /*从到达时间最早且相同的进程中查找第一个被调度的进程*/ while ((j<counter)&&(tasks[i].come_time==tasks[j].come_time))
调用 短作 业（进 程）调 度程
序
调用 响应 比高 者优 先调 度程 序
输出调度结果
2．数据输入算法
输入进程或作业个数 对每一个进程或作业
输入进程或作业名
输入进程或作业号 输入进程或作业到达时间 输入进程或作业运行时间 输入进程或作业优先级
3．数据输出算法
学海无 涯
对每个作业执行
输出进程（或作业）号、 进程（或作业）名、 到达时间、 开始运行时间、 运行结束时间、 优先级、 运行次序、 周转时间、 带权周转时间 计算并输出平均周转时间、带权周 转时间
{ max_priority=tasks[j].priority; i=j; } j++; } /*对第一个被调度的进程求相应的参数*/ number_schedul=i; tasks[number_schedul].run_begin_time=tasks[number_schedul].come_time; tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].r un_time; tasks[number_schedul].run_flag=1; temp_time=tasks[number_schedul].run_end_time; tasks[number_schedul].order=1; temp_counter=1;
学海无涯
tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].r un_time;
tasks[number_schedul].run_flag=1; temp_time=tasks[number_schedul].run_end_time; tasks[number_schedul].order=1; temp_counter=1;
{ if (tasks[j].run_time<tasks[i].run_time)
{ run_time=tasks[j].run_time; i=j; } j++; } /*对第一个被调度的进程求相应的参数*/ number_schedul=i; tasks[number_schedul].run_begin_time=tasks[number_schedul].come_time;
学海无涯
for(i=0;i<counter;i++) {
tasks[i].run_begin_time=time_temp; tasks[i].run_end_time=tasks[i].run_begin_time+tasks[i].run_time; tasks[i].run_flag=1; time_temp=tasks[i].run_end_time; number_schedul=i; tasks[number_schedul].order=i+1; } return 0; } /*非抢占式优先级调度，默认 tasks[0]是最早到达的进程，进程已按到达先后顺序排成了队列。*/ int ps() { float temp_time=0; int i=0,j; int number_schedul,temp_counter; /*正在被调度执行的进程编号和已经调度完成的进程个数*/ int max_priority; max_priority=tasks[i].priority; j=1; /* 从从到达时间最早且相同的进程中遍历，查找第一个被调度的进程*/ while ((j<counter)&&(tasks[i].come_time==tasks[j].come_time))/*寻找到达时间相同优先级最高的 进程。*/ { if (tasks[j].priority>tasks[i].priority)
/*循环查找下一个被调度的进程，直到所有的 tasks[j].run_flag ==1*/ while (temp_counter<counter) {
学海无涯
max_priority=0; for(j=0;j<counter;j++) { if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag)) if (tasks[j].priority>max_priority)
#include<stdio.h>
//using namespace std;
#define MAX 10
struct task_struct
{ char name[10]; int number; float come_time; float run_begin_time;
/*进程名称*/ /*进程编号*/ /*到达时间*/ /*开始运行时间*/
/*先来先服务*/
int ps();
/*优先级调度*/
int sjf();
/*短作业优先*/
int hrrn();
/*响应比高优先*/
int pinput(); /*进程参数输入*/
int poutput(); /*调度结果输出*/
学海无涯
void main() { int option;
pinput(); printf("请选择调度算法（0~4）:\n"); printf("1.先来先服务\n"); printf("2.优先级调度\n"); printf(" 3.短作业优先\n");
4．先来先服务调度算法描述
系统中有未运行的作业
在未运行的作业中选择一个提 交时间最早的作业 把运行次序填入数组相应位置； 分别计算出该作业进入输入井时 间、开始运行时间、运行结束时 间、周转时间、带权周转时间， 并填入数组相应位置。
调用输出程序输出结果
先来先服务调度算法
学海无 涯
5．优先级调度算法
时间、优先数、进入输入井时间、开始运行时间、尚需运行时间、运行结束时间、周转时
间、带权周转时间、运行次序等。
2
利用定义的结构体，定义一个结构体数组，用来记录系统中的作业或进程。
6.2 算法描述：
1．主控程序算法描述
学海无 涯
进程（作业）参数输入 重复执行
选择调度算法
0
1
2
3
4
调用 先来 先服 务调 度程 序
系统中有未运行的作业
在未运行的作业中选择一个响应比最 高的作业运行 （响应比相同按先来先服务进行选择）
把运行次序填入数组相应位置； 分别计算出该作业进入输入井时 间、开始运行时间、运行结束时 间、周转时间、带权周转时间， 并填入数组相应位置。
调用数据输出程序输出结果
响应比高优先调度算法
6.3 C 语言程序实现
/*循环查找下一个被调度的进程，直到所有的 tasks[j].run_flag ==1*/ while (temp_counter<counter) { /*找到在上一个进程执行期间（到“目前”为止）到达时间最晚的一个进程*/
学海无涯
实验二 进程管理
2.5 作业（进程）调度算法模拟
1. 实验目的与要求
本实验的目的是通过作业或进程调度算法模拟设计，进一步加深对作业或进程调度算法的 理 解，通过计算平均周转时间和带权平均周转时间，进一步加深对算法的评价方法的理解。
2. 实验类型：验证型 3. 实验学时：4
4. 实验原理和知识点
float run_time;
/*运行时间*/
float run_end_time;
/*运行结束时间*/
int priority; int order;
/*优先级*/ /*运行次序*/
int run_flag;
/*调度标志*/
}tasks[MAX];
int counter; /*实际进程个数*/
int fcfs();
有未运行的作业
作业的优先数 与 Pnim 比较 大
Pmin该作业 的优先数 k该作业的 在数组中的下标
6．短作业（或进程）优先调度算法
未找到
找到
有未运行的作业
作业的运行时间
与 Rnim 比较
长
短
Rmin该作业 的运行时间 k该作业的 在数组中的下标
选择运行时间最短作业的算法
学海无 涯
7．响应比高优先调度算法
break; case 2:
printf("对进程按优先级调度。\n\n"); ps();
poutput(); break; case 3:
printf("对进程按短作业优先调度。\n\n"); sjf();
poutput(); break; case 4: