优先级法、非强占式短进程优先算法
非抢占式优先级调度算法

非抢占式优先级调度算法1. 简介非抢占式优先级调度算法是一种常用的进程调度算法,它根据进程的优先级来确定调度顺序。
在该算法中,每个进程被分配一个优先级,优先级高的进程会先被调度执行,而优先级低的进程则会被延后执行。
2. 算法原理非抢占式优先级调度算法的原理相对简单,主要包括以下几个步骤:1.初始化:为每个进程分配一个优先级,并将它们按照优先级的高低进行排序。
2.调度:根据优先级高低,依次选择优先级最高的进程进行执行,直到所有进程执行完毕。
3.更新优先级:在每个时间片结束后,根据一定的策略更新进程的优先级,以保证公平性和避免饥饿现象。
3. 算法实现3.1 进程优先级的确定进程优先级的确定可以根据进程的特性和重要程度来进行评估。
一般来说,重要性较高的进程应该被赋予较高的优先级,以确保其能够及时得到执行。
在具体实现中,可以根据进程的类型、紧急程度、资源需求等因素来确定优先级的权重。
3.2 进程调度顺序的确定在非抢占式优先级调度算法中,进程的调度顺序是根据优先级来确定的。
优先级高的进程会先被调度执行,而优先级低的进程则会被延后执行。
在实际实现中,可以使用一个优先队列来存储待调度的进程,每次选择优先级最高的进程进行执行。
3.3 进程优先级的更新为了保证公平性和避免饥饿现象,进程的优先级需要定期更新。
更新的策略可以根据具体需求来确定,常见的策略包括:•时间片轮转:每个进程执行一个时间片后,降低其优先级,使其他进程有机会得到执行。
•动态优先级调整:根据进程的运行状态和资源使用情况,动态调整进程的优先级,以平衡系统的整体性能。
4. 算法特点非抢占式优先级调度算法具有以下特点:1.简单易实现:算法原理简单,易于理解和实现。
2.公平性:优先级较低的进程也能够得到执行的机会,避免了饥饿现象的发生。
3.灵活性:可以根据具体需求选择不同的优先级更新策略,以适应不同的应用场景。
5. 应用场景非抢占式优先级调度算法适用于以下场景:1.实时系统:对于实时性要求较高的系统,可以根据任务的紧急程度来确定优先级,确保高优先级任务能够及时得到执行。
操作系统题目第3章

第三章处理机调度与死锁1、时间片轮转调度算法是为了()。
A、多个用户能及时干预系统B、使系统变得高效C、优先级较高的进程得到及时响应D、需要CPU时间最少的进程最先做2、()有利于CPU繁忙型的作业,而不利于I/O繁忙型的作业。
A、时间片轮转调度算法B、先来先服务调度算法C、短作业(进程)优先算法D、优先权调度算法3、下面有关选择进程调度算法的准则中不正确的是()。
A、尽快响应交互式用户的请求B、尽量提高处理器利用率C、尽可能提高系统吞吐量D、适当增长进程就绪队列的等待时间4、设有4个作业同时到达,每个作业的执行时间均为2h,它们的一台处理器上按单道式运行,则平均周转时间为()。
A、1hB、5hC、2.5hD、8h5、若每个作业只能建立一个进程,为了照顾短作业用户,应采用();为了照顾紧急作业用户,应采用();为了能实现人机交互,应采用();而能使短作业、长作业和交互作业用户都满意,应采用()。
A、FCFS调度算法B、短作业优先调度算法C、时间片轮转调度算法D、多级反馈队列调度算法E、剥夺式优先级调度算法6、()优先级是在创建进程时确定的,确定之后在整个运行期间不在改变。
A、先来先服务B、动态C、短作业D、静态7、现在有三个同时到达的作业J1、J2和J3,它们的执行时间分别是T1、T2、T3,且T1<T2<T3。
系统按单道方式运行且采用短作业优先调度算法,则平均周转时间是()A、T1+T2+T3 B、(3×T1+2×T2+T3)/3C、(T1+T2+T3)/3D、(T1+2×T2+3×T3)/38、设有三个作业,其运行时间分别是2h、5h、3h,假定它们同时达到,并在同一个处理器上以单道方式运行,则平均周转时间最小的执行顺序是()A、J1,J2,J3B、 J3 ,J2,J1C、J2,J1,J3D、 J1 ,J3 ,J29、采用时间片轮转调度算法分配CPU时,当处于运行状态的进程用完一个时间片后,它的状态是()状态。
操作系统的调度算法优先级时间片和占式调度

操作系统的调度算法优先级时间片和占式调度操作系统的调度算法:优先级、时间片和抢占式调度操作系统是计算机系统中的一个核心组件,用于管理和控制计算机的硬件和软件资源,以提供良好的用户体验和系统性能。
在操作系统中,调度算法是实现任务分配和资源管理的关键。
本文将介绍三种常见的调度算法:优先级调度、时间片轮转调度和抢占式调度。
一、优先级调度算法优先级调度算法是根据任务的优先级安排任务的执行顺序。
每个任务都有一个优先级值,数值越高表示优先级越高。
当一个任务就绪并等待执行时,调度器会选择优先级最高的任务来执行。
优先级调度算法可以保证高优先级任务及时得到执行,但可能会导致低优先级任务出现饥饿现象。
实际上,优先级调度算法可以分为静态优先级和动态优先级两种类型。
静态优先级是在任务创建时分配的,不会改变。
动态优先级根据任务的运行情况和系统状态进行动态调整,以提高系统的公平性和性能。
二、时间片轮转调度算法时间片轮转调度算法是一种周期性调度算法,每个任务被分配一个固定的时间片(时间段),当任务的时间片用完后,调度器会将任务挂起,并将CPU 分配给下一个任务执行。
当所有任务都执行完一次后,调度器会重新分配时间片,继续按照顺序执行任务。
时间片轮转调度算法可以保证任务的平均执行时间,并且避免了长时间任务的霸占资源问题。
然而,如果任务的时间片设置得过小,则会增加任务切换的开销。
如果任务的时间片设置得过大,则可能出现对实时任务响应时间的影响。
三、抢占式调度算法抢占式调度算法是一种灵活的调度策略,允许更高优先级的任务打断正在执行的低优先级任务,以确保高优先级任务的及时响应。
当一个任务就绪并具备运行条件时,调度器会立即安排其执行,无论当前是否有其他任务在执行。
抢占式调度算法可以有效地提高系统的响应速度和实时性,但可能会导致任务切换的频繁发生,增加了系统开销。
为了平衡性能和实时性的需求,抢占式调度算法通常会和其他调度策略结合使用,例如优先级和时间片轮转。
非抢占式优先级调度算法

非抢占式优先级调度算法
非抢占式优先级调度算法(Non-Preemptive Priority Scheduling Algorithm)是一种用于处理进程调度的算法。
该算法根据进
程的优先级来决定执行顺序,高优先级的进程先执行,低优先级的进程后执行。
与抢占式优先级调度算法不同的是,非抢占式优先级调度算法不会中断正在执行的进程,直到该进程完成或者发生某种阻塞事件。
非抢占式优先级调度算法的实现流程如下:
1. 每个进程都有一个优先级值,通常是一个整数,数值越小表示优先级越高。
2. 在算法开始前,根据每个进程的优先级值对进程进行排序,将优先级最高的进程排在最前面。
3. 从排序后的进程列表中选择优先级最高的进程开始执行。
4. 执行该进程直到完成或者发生某种阻塞事件。
5. 如果进程完成,从进程列表中移除该进程,继续选择下一个优先级最高的进程执行。
6. 如果进程发生某种阻塞事件,暂停该进程的执行,执行其他可以执行的进程,直到该进程的阻塞事件解除。
7. 重复步骤3到步骤6,直到所有进程都执行完毕。
非抢占式优先级调度算法的特点是简单且容易实现,适用于一些实时系统或者对响应时间要求较高的应用场景。
但是该算法存在优先级反转的问题,即优先级较低的进程可能因为被优先级较高的进程阻塞而无法执行,从而影响整个系统的性能。
为了解决这个问题,可以引入优先级继承或者优先级反转的机制。
非抢占式高优先级调度算法

/*非抢占式高优先级调度算法(优先数越大级别越高)算法思想:在按进程达到时间由小到大的顺序输入进程信息后,先对其优先数进行排列,将最先到达的进程的到达时间设为开始时间,计算结束时间,然后对后面到达的时间与该进程的结束时间进行比较,如若小于该进程的结束时间,记录进程的个数,再对其优先数逐个进行比较,将优先数最大的提到前面,每次进程结束都要进行比较,得到执行序列,在依次输出结果*/#include<stdio.h>#define MAX 100struct hrfs{char name[10];float arrvitetime;float starttime;float servietime;float finishtime;int priority;//优先数int order;//进程执行次序int run_flag;//标记进程状态};hrfs p[MAX];int count;//排列到达时间//按到达时间与优先数计算执行序列void HRfs(){float temp_time=0;int i=0,j;int k,temp_count;int max_priority;max_priority=p[i].priority;j=1;while((j<count)&&(p[i].arrvitetime==p[j].arrvitetime)){if(p[j].priority>p[i].priority){max_priority=p[j].priority;i=j;}j++;}k=i;p[k].starttime=p[k].arrvitetime;//开始时间=达到时间p[k].finishtime=p[k].starttime+p[k].servietime;p[k].run_flag=1;temp_time=p[k].finishtime;p[k].order=1;temp_count=1;while(temp_count<count){max_priority=0;for(j=0;j<count;j++){//判断到达时间是否小于上一个进程的结束时间并且非处在运行状态if((p[j].arrvitetime<=temp_time)&&(!p[j].run_flag))//判断进程优先数是否大于最大优先数,如果大于,就将其值赋给max_priorityif(p[j].priority>max_priority){max_priority=p[j].priority;k=j;}}p[k].starttime=temp_time;p[k].finishtime=p[k].starttime+p[k].servietime;p[k].run_flag=1;temp_time=p[k].finishtime;temp_count++;p[k].order=temp_count;}}void input(){int i;printf("\n请输入进程名到达时间运行时间优先数,例如:a 0 100 1\n");for(i=0;i<count;i++){printf("进程%d的信息:",i+1);scanf("%s%f%f%d",p[i].name,&p[i].arrvitetime,&p[i].servietime,&p[i].priority);p[i].starttime=0;p[i].finishtime=0;p[i].order=0;p[i].run_flag=0;}}void print(){int i;float turn_round_time=0,f1,w=0;float right_turn_round_time;printf("\n-------------------------------进程完成信息------------------------------------\n");printf("进程名优先级达到时间运行时间开始时间结束时间周转时间带权周转时间运行次序\n");for(i=0;i<count;i++){f1=p[i].finishtime-p[i].arrvitetime;turn_round_time+=f1;right_turn_round_time=f1/p[i].servietime;w+=(f1/p[i].servietime);printf("%s %5d %10.2f %8.2f %8.2f %8.2f %8.2f %8.2f %8d\n",p[i].name,p[i].priority,p[i].a rrvitetime,p[i].servietime,p[i].starttime,p[i].finishtime,f1,right_turn_round_time,p[i].order);}printf("平均周转时间=%5.2f\n",turn_round_time/count);printf("平均带权周转时间=%5.2f\n",w/count);}void main(){printf("---------------------------非抢占式高优先级调度算法----------------------------\n");printf("进程个数:");scanf("%d",&count);input();HRfs();print();}。
最短作业优先(抢占和非抢占)

最短作业优先(抢占和非抢占)一、流程图解析:在最开始,我们先创建若干进程,选择自动运行,则在运行完后,按顺序显示运行的结果。
同理,选择手动运行,那么就是最先选择最短的作业开始运行,其实当前进程并非一定在实际运行(改变自己的状态),只是一个虚拟的运行(虚拟最短作业优先运行算法),这时我们可以做其他的事情,在做事之前,先运行虚拟算法,依照最短作业优先去改变相关进程的状态(进程可能就没有实际运行过,被虚拟算法改变了状态(就绪、等待、终止)),在做完相关事情之后,再运行虚拟算法,确定是否要发生最短作业的优先抢占。
根据以上的运行结构,我们可以在这结构的基础上,人为地设置进程状态就是改变进程状态,这时就可以发生最短作业调度的抢占和非抢占式。
我们可以进入查看进程状态,看看运行的状况,也可以进入修改进程状态,修改相关进程状态让其发生最短作业的抢占,或者进入创建进程,创建一个新的进程,这是也有可能实现最短作业优先的抢占。
二、虚拟运行算法:从进程的结构分析,进程里面有状态,到达时间(取系统时间),结束时间(取系统时间),需要运行时间,已运行时间等,我们知道第一个最短作业运行的到达时间(开始运行的时间)就是创建的时间。
在一个进程运行终止时,要设好终止的时间、改变状态等属性,这时进行进程间信息交换,终止进程的时间交给下一个要运行的进程的到达时间,这样不断下去就可以运行到最后一个进程,当发生抢占调度时,也是以上的情况运行。
先在抢占之前,就运行虚拟算法,改变相关的进程状态,发生引起抢占的事的时候就可以利用抢占来进行进程的切换。
这样就能让CPU在有工作做时就不能空闲。
直到把所有在就绪队列的进程运行完,这是CPU可以休息了,如果在CPU休息时有进程从等待进入就绪,那么CPU就要继续开工。
当我们运行完第一批输入的进程,现在CPU在空转,我们又创建了新进程,这时新进程就在创建那一刻起开始运行了,因为新进程创建好就进入了就绪的状态。
操作系统典型调度算法

操作系统典型调度算法在操作系统中存在多种调度算法,下⾯介绍⼏种常⽤的调度算法。
先来先服务(FCFS)调度算法FCFS调度算法是⼀种最简单的调度算法,FCFS调度算法每次从就绪队列中选择最先进⼊该队列的进程,将处理机分配给它,使之投⼊运⾏,直到完成或因某种原因⽽阻塞时才释放处理机。
下⾯通过⼀个实例来说明FCFS调度算法的性能。
假设系统中有4个作业,它们的提交时间分别是8、8.4、8.8、9,运⾏时间依次是2、1、0.5、0.2,系统⾤⽤FCFS调度算法,这组作业的平均等待时间、平均周转时间和平均带权周转时间见表2-3。
表2-3 FCFS调度算法的性能作业号提交时间运⾏时间开始时间等待时间完成时间周转时间带权周转时间18280102128.4110 1.611 2.6 2.638.80.511 2.211.5 2.7 5.4490.211.5 2.511.7 2.713.5平均等待时间 t = (0+1.6+2.2+2.5)/4=1.575平均周转时间 T = (2+2.6+2.7+2.7)/4=2.5平均带权周转时间 W = (1+2.6+5.牡13.5)/4=5.625FCFS调度算法属于不可剥夺算法。
从表⾯上看,它对所有作业都是公平的,但若⼀个长作业先到达系统,就会使后⾯许多短作业等待很长时间,因此它不能作为分时系统和实时系统的主要调度策略。
但它常被结合在其他调度策略中使⽤。
例如,在使⽤优先级作为调度策略的系统中,往往对多个具有相同优先级的进程按FCFS原则处理。
FCFS调度算法的特点是算法简单,但效率低;对长作业⽐较有利,但对短作业不利(相对SJF和⾼响应⽐);有利于CPU繁忙型作业,⽽不利于I/O繁忙型作业。
短作业优先(SJF)调度算法短作业(进程)优先调度算法是指对短作业(进程)优先调度的算法。
短作业优先(SJF)调度算法是从后备队列中选择⼀个或若⼲个估计运⾏时间最短的作业,将它们调⼊内存运⾏。
非抢占式优先级调度算法

非抢占式优先级调度算法摘要:一、引言二、非抢占式优先级调度算法的定义及原理三、非抢占式优先级调度算法的应用场景四、非抢占式优先级调度算法的优缺点五、发展趋势与展望六、总结正文:一、引言在计算机系统中,进程调度是操作系统核心部分的重要组成部分。
非抢占式优先级调度算法是进程调度中的一种经典算法,它根据进程的优先级进行调度,确保高优先级的进程优先获得CPU资源。
本文将对非抢占式优先级调度算法进行详细介绍,包括其定义、原理、应用场景、优缺点以及发展趋势与展望。
二、非抢占式优先级调度算法的定义及原理非抢占式优先级调度算法是一种进程调度策略,其主要特点是高优先级的进程优先执行,低优先级的进程在有空闲CPU资源时才执行。
在该算法中,进程的优先级分为静态优先级和动态优先级两种。
静态优先级在进程创建时确定,动态优先级则根据进程运行过程中的需求进行调整。
非抢占式优先级调度算法的原理如下:1.操作系统维护一个进程优先级队列,队列中的进程按照优先级从高到低排列。
2.当CPU空闲时,从队列头部取出一个进程执行。
3.若高优先级进程正在执行,低优先级进程到达就绪状态,也不能抢占CPU资源,必须等待高优先级进程执行完毕后才能执行。
4.进程执行过程中,若优先级发生变化,可以根据新的优先级调整队列顺序。
三、非抢占式优先级调度算法的应用场景非抢占式优先级调度算法适用于对优先级要求较高的场景,例如实时操作系统、嵌入式系统等。
在这些系统中,实时性、可靠性要求较高,需要确保关键进程能够及时执行。
非抢占式优先级调度算法能够满足这些需求,提高系统的运行效率。
四、非抢占式优先级调度算法的优缺点优点:1.实时性较好,能确保高优先级进程及时执行。
2.资源利用率较高,低优先级进程在有空闲资源时可以执行。
3.实现简单,易于理解和管理。
缺点:1.可能导致低优先级进程长时间得不到执行,影响系统性能。
2.高优先级进程执行过程中,低优先级进程不能及时响应,可能导致实时性下降。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
学号:课程设计题目进程调度模拟设计——优先级法、非强占式短进程优先算法学院计算机专业班级姓名指导教师吴利军2013 年 1 月16 日课程设计任务书学生姓名:指导教师:吴利军工作单位:计算机科学与技术学院题目: 进程调度模拟设计——优先级法、非强占式短进程优先算法初始条件:1.预备内容:阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有深入的理解。
2.实践准备:掌握一种计算机高级语言的使用。
要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求)1.模拟进程调度,能够处理以下的情形:⑴能够选择不同的调度算法(要求中给出的调度算法);⑵能够输入进程的基本信息,如进程名、优先级、到达时间和运行时间等;⑶根据选择的调度算法显示进程调度队列;⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。
2.设计报告内容应说明:⑴需求分析;⑵功能设计(数据结构及模块说明);⑶开发平台及源程序的主要部分;⑷测试用例,运行结果与运行情况分析;⑸自我评价与总结:i)你认为你完成的设计哪些地方做得比较好或比较出色;ii)什么地方做得不太好,以后如何改正;iii)从本设计得到的收获(在编写,调试,执行过程中的经验和教训);iv)完成本题是否有其他方法(如果有,简要说明该方法);时间安排:设计安排一周:周1、周2:完成程序分析及设计。
周2、周3:完成程序调试及测试。
周4、周5:验收、撰写课程设计报告。
(注意事项:严禁抄袭,一旦发现,一律按0分记)指导教师签名:年月日系主任(或责任教师)签名:年月日进程调度模拟设计--优先级法、非强占式短进程优先算法一.问题描述设计一程序模拟进程调度,能够选择优先级和非抢占短作业两种算法对进程调度。
可以输入相关进程信息(进程名,达到时间,执行时间,优先级),最终能显示进程调度的序列。
并能显示这些进程的平均周转时间和带权平均周转时间。
二.需求分析通过设计一个模拟进程调度的系统,来实现进程调度,对进程调度的功能以及进程调度算法有一个更加深入的理解。
进程PCB(包含进程名、到达时间、预计运行时间)调度算法(优先级、非强占式短进程优先)模拟进程调度,能够处理以下的情形:⑴能够选择不同的调度算法(要求中给出的调度算法);⑵能够输入进程的基本信息,如进程名、到达时间和运行时间等;⑶根据选择的调度算法显示进程调度队列;⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。
此次做的进程调度模拟系统,用户可以输入各进程信息(包含进程名、到达时间、运行时间)。
输入进程数,然后输入进程的提交时间和运行时间,显示优先级和非强占式短进程优先调度算法的进程名、提交时间、运行时间、开始时间、结束时间、周转时间、带权周转时间、执行时间、平均周转时间和平均带权周转时间。
优先级法:优先级法可被用做作业或进程的调度策略。
首先,系统或用户按某种原则为作业或进程指定一个优先级来表示该进程或作业所享有的优先权。
改算法的核心是确定进程或作业的优先级。
确定优先级的方法可分为两类。
即静态法和动态法。
静态法根据作业的或进程的静态特性,在作业或进程开始执行前就确定它们的优先级,一旦开始执行之后就不能改变。
动态法则不然,它把作业或进程的静态特性结合起来确定作业或进程的优先级,随着作业或进程的执行过程,其优先级不断变化。
非抢占短作业优先法:不可抢占式 Non-preemptive(非剥夺式):某一进程被调度运行后,除非由于它自身的原因不能运行,否则一直运行下去。
短作业优先调度算法(SJF, Shortest Job First),又称为“短进程优先”SPN(Shortest Process Next);这是对FCFS算法的改进,其目标是减少平均周转时间。
基本思想:对预计执行时间短的作业(进程)优先处理。
通常后来的短作业不抢先正在执行的作业。
在一般情况下这种调度算法比先来先服务调度算法的效率要高一些。
实现相对先来先服务调度算法要困难些,如果作业的到来顺序及运行时间不合适,会出现饿死现象,例如,系统中有一个运行时间很长的作业J,和几个运行时间小的作业,然后,不断地有运行时间小于J的作业的到来,这样,作业J就得不可调度而饿死。
另外,作业运行的估计时间也有问题。
三.功能设计1.数据结构在此次课程设计中主要采用了结构体数组的存储方式,将一个进程信息存储在一个结构体中,包括进程名称、进程优先级、进程提交时间、进程运行时间、进程周转时间。
具体实现如下:struct PRO{char name[10];//进程名float arrivetime;进程时间float servicetime;//进程执行时间float starttime;//开始时间float finishtime;//完成时间int xy; //优先级float zztime;//周转时间float dqzztime;//带权周转时间};2.程序流程框图优先级②非抢占式短作业优先③综合流程图3.模块说明本次课程设计中一共涉及五个模块(结构体定义,要处理进程信息的输入,两种算法的实现,处理完毕后进程信息的输出,主函数)(1)结构体定义如上所示(2)进程信息的输入void input(PRO *p,int n)P为结构体数组名,n为进程个数。
(3)两种算法的实现优先级算法的具体实现void YX(PRO *p,int N){floatarrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0;float dqzztime;int xy=0;sortxy(p,N);//基于时间的排序同时处理多个进程同时到达情况。
for(int m=0;m<N-1;m++){if(m==0)p[m].finishtime=p[m].arrivetime+p[m].servicetime;elsep[m].finishtime=p[m-1].finishtime+p[m].servicetime;int i=0;for(int n=m+1;n<=N-1;n++){if(p[n].arrivetime<=p[m].finishtime)i++;}float min=p[m+1].xy;int next=m+1;//m+1=nfor(int k=m+1;k<m+i;k++){if(p[k+1].xy<min){min=p[k+1].xy;next=k+1;}}PRO temp;temp=p[m+1];p[m+1]=p[next];p[next]=temp;} //令优先级高的执行deal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztim e,N,xy);//将排好序的进程处理计算出其周转时间和带权周转时间print(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N ,xy);//输出处理完毕后进程信息}非抢占式短作业优先void SJF(PRO *p,int N){floatarrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0;float dqzztime=0;int xy=0;sortt(p,N);//按到达时间进行排序printf(p[0].name);for(int m=0;m<N-1;m++){if(m==0)p[m].finishtime=p[m].arrivetime+p[m].servicetime;elsep[m].finishtime=p[m-1].finishtime+p[m].servicetime;int i=0;for(int n=m+1;n<=N-1;n++){if(p[n].arrivetime<=p[m].finishtime)i++;}//得出在第m+1个进程执行完之前有多少个进程需要进行比较float min=p[m+1].servicetime;int next=m+1;//m+1=nfor(int k=m+1;k<m+i;k++){if(p[k+1].servicetime<min){min=p[k+1].servicetime;next=k+1;}}//PRO temp;temp=p[m+1];p[m+1]=p[next];p[next]=temp;} //将执行时间最短的进程放在数组最前面deal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N, xy);//将排好序的进程处理计算出其周转时间和带权周转时间print(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N ,xy);//输出处理完毕后进程信息}(4)处理完进程信息的输出void print(PRO *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N,int xy)(5)主函数主要设计一个菜单功能。
四.开发平台及源代码主要部分1.开发平台Visual Stdio 20102.源代码主要部分五.测试用例,运行结果与运行情况分析1.测试优先级①进程在同一时刻到达进程名进程到达时间进程执行时间进程优先级a 0 2 3b 0 4 2c 0 7 1可以得出当进程同时到达时,按优先级顺序执行。
②当进程不是同时到达,且优先级高的到的比较晚。
进程名进程到达时间进程执行时间优先级a 0 3 3b 1 4 2c 6 5 1从这个实例可以得出尽管c的优先级最高,但它最后到达,所以在c之前会执行已到达的进程。
当进程不是全部同时到达,但有部分同时到达。
进程名进程到达时间进程执行时间优先级a 1 2 2b 0 6 3c 1 7 1尽管b的优先级最低,但其最先到达,所以最先执行,由于a,c进程,c进程的优先级高,所以c先执行。
2.测试非抢占短作业优先①当进程同时到达进程名进程到达时间进程处理时间优先级a 0 5 1b 0 1 2c 0 2 3由于同时到达,那个进程执行时间短就先执行。
②当进程全部不是同时到达进程名进程到达时间进程执行时间优先级a 3 2 1b 4 6 2c 9 1 3尽管c的执行时间最短,但因为其最后到达,之前cpu空闲,所以就先执行完前面到达的进程。