短作业优先算法例题
1实验一先来先服务FCFS和短作业优先SJF进程调度算法
实验一先来先服务FCFS和短作业优先SJF进程调度算法一：需求分析程序设计的任务：设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。
假设有n个x进程分别在T1，… ,Tn时刻到达系统,它们需要的服务时间分别为S1，… ，Sn.分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度，计算每个进程的完成时间、周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。
通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。
（1）输入的形式和输入值的范围为免去测试时候需要逐步输入数据的麻烦,输入时采用输入文件流方式将数据放在。
txt 文件中，第一行为进程个数，第二行为进程到达时间（各个进程的到达时间之间用空格隔开），第三行为进程的服务时间（每个服务时间之间用空格隔开）。
（2）输出的形式模拟整个调度过程，输出每个时刻的进程运行状态，同时输出了每个进程的完成时间，并且按要求输出了计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。
（3）程序所能达到的功能能够模拟出进程的先来先服务FCFS算法和短作业优先SJF算法的调度过程，输入进程个数n；每个进程的到达时间T1, … ，Tn和服务时间S1, … ,Sn;选择算法1-FCFS,2-SJF,3—退出，用户做出选择即可输出对应的算法调度过程或者退出程序。
（4）测试数据,包括正确的输入及其输出结果和含有错误的输入及其输出结果测试数据及其输出结果:二:概要设计程序包括主函数、FCFS算法函数、SJF算法函数、输出函数;主函数流程：输入文件中的数据—显示各进程数据-选择算法-调用相应算法的函数-输出结果三：详细设计算法流程图：调用结束四:调试分析(1)：调试过程中遇到的问题以及解决方法，设计与实现的回顾讨论和分析;开始的时候没有判断进程是否到达，导致短进程优先算法运行结果错误，后来加上了判断语句后就解决了改问题。
操作系统的先来先服务 最短作业优先
Shell编程题目1. 创建以下bash文件并执行找出100以内所有7的倍数。
提示：利用取余数运算%，当余数为0表示判断一个数是另一个数的整数倍。
题目2：创建以下bash文件并执行计算指定整数范围内的素数/质数的个数。
例如，#./2.sh 50 60将输出50和60之间的素数个数2。
（注：素数指，只能被1和自身整除的整数。
）Shell编程题1：#!/bin/bashx=1while [ $x –le 100 ];doa=$(expr $x % 7 )if [ $a –eq 0]; thenecho “$x”fix=$(expr $x + 1 )doneShell编程题2：#!/bin/bash#check argumentsif [ $# -lt 2 ];thenecho "argument number error!"exit 1fia=$1b=$2#one is not primeif [ $a -gt 1 ];thena2=$aelsea2=2finum=0x=$a2while [ $x -le $b]; do#check x is prime or notflag=1y=2while [ $y -lt $x ]; doc=$(expr $x % $y )if [ $c -eq 0 ]; thenflag=0fiy=$(expr $y + 1 )doneif [ $flag -eq 1 ];thenecho "$x"num=$(expr $num + 1 )fix=$(expr $x + 1 )doneecho "number of primes in [$a, $b] is $num."//按作业的到达顺序输入各作业的到达时间及需要的运行时间，按算法调度输出平均周转时间//FCFS顺序//2013.5.10#include<iostream>using namespace std;#define M 100void main(){double arrivetime[M]; //到达时间double spendtime[M]; //各自的运行时间double costtime[M]; //各自的周转时间double sum=0,ave;int N;cout<<"请输入作业个数：\n";cin>>N;cout<<"请依次输入四个作业分别到达的时间(单位：小时)：\n";for(int i=0;i<N;i++){cin>>arrivetime[i];}cout<<"请依次输入四个作业分别需要运行的时间(单位：小时)：\n";for(int j=0;j<N;j++){cin>>spendtime[j];}double m=arrivetime[0];int l=0;for(int k=0;k<N;k++) //求出各自的周转时间{if(arrivetime[k]<=m){m+=spendtime[l];costtime[k]=m-arrivetime[k];l++;}else{m=arrivetime[k]+spendtime[k];costtime[k]=spendtime[k];l++;}}for(int n=0;n<N;n++){sum+=costtime[n];}ave=sum/N;cout<<"平均周转时间："<<ave<<endl;}//SJF算法#include<iostream>using namespace std;void main(){double arrivetime[20]; //到达的时间double spendtime[20]; //各作业所需要的时间double costtime[20]; //各自的周转时间int N;double ave;double sum;cout<<"请输入作业的个数：";//输入作业的个数cin>>N;cout<<"请依次输入四个作业分别到达的时间(单位：小时)：\n";for(int i=0;i<N;i++){cin>>arrivetime[i];}cout<<"请依次输入四个作业分别需要运行的时间(单位：小时)：\n";for(int j=0;j<N;j++){cin>>spendtime[j];}int temp,temp1;for(int k=1;k<N;k++){for(int l=k+1;l<N;l++){if(spendtime[k]>spendtime[l]){temp=spendtime[k];spendtime[k]=spendtime[l];spendtime[l]=temp;temp1=arrivetime[k];arrivetime[k]=arrivetime[l];arrivetime[l]=temp1;}}}double w=arrivetime[0];int p=0;for(int n=0;n<N;n++) //求出各自的周转时间{if(arrivetime[n]<=w){w+=spendtime[n];costtime[n]=w-arrivetime[n];p++;}else{w=arrivetime[n]+spendtime[n];costtime[n]=spendtime[n];p++;}}for(int t=0;t<N;t++){sum+=costtime[t];}ave=sum/N;cout<<"平均周转时间："<<ave<<endl;}FIFO#include<iostream>using namespace std;#define M 100void main(){int page[M]; //存进的页面int visit[M]; //页面访问顺序char flag,f[M]; //标志是否有缺页现象int table[M][M]; //打印int p,v;int i,j,k,t;cout<<"please enter your number of pages:";cin>>p;cout<<"plase enter your number of visiting:";cin>>v;cout<<"plase enter your order of visiting:";for(i=0;i<v;i++){cin>>visit[i];}for(i=0;i<p;i++){page[i]=9;}t=0; //记录缺页次数for(i=0;i<v;i++){k=0; //判断是否缺页flag=' ';while((visit[i]!=page[k])&&(k!=p)) k++;if(k==p){flag='*'; //有缺页现象t++;}elseflag=' ';if(flag=='*'){for(j=p-1;j>0;j--)page[j]=page[j-1];page[0]=visit[i];}for(k=0;k<p;k++){table[k][i]=page[k];}f[i]=flag;}cout<<"输出结果为下表（9代表为空，*代表有缺页）：\n";for(i=0;i<p;i++){ //打印for(j=0;j<v;j++){cout<<table[i][j]<<" ";}cout<<endl;}for(i=0;i<v;i++){cout<<f[i]<<" ";}cout<<endl<<"共有"<<t<<"次缺页。
操作系统例3.4
分析
作业A先进入内存，运行了20分，B进入内 存，B的优先级高，所以B抢占A优先运行 ，B运行40分结束，9:00，A继续运行剩下 的30分，D进入内存，A运行完，9:30，C 进入，C比D优先级高，C运行，最后D运行 。 周转时间：A：9:30-8:00 B：9:00-8:20 C：10:30-8:30 D：11:00-8:50
批处理——优先级算法
优先级调度算法是为每一作业规定一个优先 级，而优先级是用优先数来表示的，规定 优先数越小，优先级越高（或者规定优先 级越大，优先级越高）。 SJF可以作为作为优先级算法的一个特例
计算公式
作业的周转时间=完成时间-提交时间 作业的带权周转时间=作业的周转时间/运行时间 平均周转时间=各作业的周转时间之和/作业数目 平均带权周转时间=各作业的带权周转时间之和/作业数 目
作业名 A B 到达时间 8：00 8：20 估计运算时间 50分 40分 优先数 4 2
C D
8：30 8：50
60分业优先算法
最短作业优先算法是以进入系统的作业所 要求的CPU时间长短为标准，总是选取估 计计算时间最短的作业投入运行。
注意：这里是指使用CPU时间最短 ，而不是程序最短。
4 2 3
8:00 8:20 9:30
9:30 9:00
1.30 0.40
8:20 9:30
10:30 2.00
D
8:50
0.30
6
9:00
10:30 11:00 2.10
2、作业平均周转时间为
T=（90+40+120+130）/4=95
谢谢观赏
Make Presentation much more fun
最短作业优先调度算法(SJF算法)的C++实现
在作业调度中，该算法每次从后备作业队列中挑选估计服务时间最短的一个或几个作业，将他们调入内存，分配必要的资源，创建进程并放入就绪队列。
与在进程调度中的原理类似。
假设有n项作业位于就绪队列中，这些作业的请求时间用数组requestTimes按照提交时间的先后顺序存储，对应的作业服务时间（也称持续时间）用数组durations存储。
当每个作业被完成后，接下来优先选择服务时间（持续时间）短的，如果多个服务时间一样，则优先选择请求时间最先的。
采用SJF算法，计算n项作业的平均等待时间。
所有要执行的任务的请求时间必须在上一个任务完成的时间内。
假设0<= n <= 100。
测试用例：
requestTimes = {0, 2, 4, 5};
durations = {7, 4, 1, 4};
可以理解为一定首先执行第一个任务，请求时间为0，执行了7个时间单位；
接下来在服务时间最短的中选择，显然是任务3，请求时间为4，执行1个时间单位；
再接下来发现2和4这两个任务服务时间一样短，则优先选择请求时间最先的，显然是选择任务2，执行4个时间单位
最后是任务4（并且只有任务4了），请求时间为5，执行4个时间单位
等待时间：任务1是0，任务3是3，任务2是5，任务4是7，所以平均等待时间是4。
短作业优先算法
短功课（进程）优先调度算法之杨若古兰创作1.短功课（进程）优先调度算法SJ（P）F，是指对短功课或短进程优先调度的算法.它们可以分别用于功课调度和进程调度.短功课优先（SJF）的调度算法是从后备队列当选择一个或若干个估计运转时间最短的功课，将它们调入内存运转.而短进程（SPF）调度算法则是从就绪队列当选出一个估计运转时间最短的进程，将处理机分配给它，使它立即履行并不断履行到完成，或发生某事件而被梗阻放弃处理机再从头调度.SJ(P)F调度算法能无效地降低功课（进程）的平均等待时间，提高零碎吞吐量.该算法对长功课晦气，完整未考虑功课的紧迫程度.2.流程图3.代码#include<iostream.h>#include<string.h>#include<stdlib.h>struct sjf{char name[10];float arrivetime;float servicetime;float starttime;float finishtime;float zztime;float dqzztime;};sjf a[100];void input(sjf *p,int N){ int i;printf("intput the process's name & arrivetime & servicetime:\nfor exmple: a 0 100\n");for(i=0;i<=N1;i++){printf("input the %dth process's information:\n",i+1);scanf("%s%f%f",&p[i].name,&p[i].arrivetime,&p[i].ser vicetime);}}void Print(sjf *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N) {int k;printf("run order:");printf("%s",p[0].name);for(k=1;k<N;k++){printf(">%s",p[k].name);}printf("\nthe process's information:\n");printf("\nname\tarrive\tservice\tstart\tfinish\tzz\tdqzz\n ");for(k=0;k<=N1;k++){ printf("%s\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t\n", p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k]. finishtime,p[k].zztime,p[k].dqzztime);}}//pai xuvoid sort(sjf *p,int N){for(int i=0;i<=N1;i++)for(int j=0;j<=i;j++)if(p[i].arrivetime<p[j].arrivetime){sjf temp;temp=p[i];p[i]=p[j];p[j]=temp;}}//yun xing jieduanvoid deal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N){ int k;for(k=0;k<=N1;k++){if(k==0){p[k].starttime=p[k].arrivetime;p[k].finishtime=p[k].arrivetime+p[k].servicetime;}else{p[k].starttime=p[k1].finishtime;p[k].finishtime=p[k1].finishtime+p[k].servicetime;} }for(k=0;k<=N1;k++){p[k].zztime=p[k].finishtimep[k].arrivetime;p[k].dqzztime=p[k].zztime/p[k].servicetime;}}void sjff(sjf *p,int N){floatarrivetime=0,servicetime=0,starttime=0,finishtime=0,zztim e=0,dqzztime=0;sort(p,N);for(int m=0;m<N1;m++){if(m==0)p[m].finishtime=p[m].arrivetime+p[m].servicetime;elsep[m].finishtime=p[m1].finishtime+p[m].servicetime;int i=0;for(int n=m+1;n<=N1;n++){if(p[n].arrivetime<=p[m].finishtime)i++;}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;}}sjf temp;temp=p[m+1];p[m+1]=p[next];p[next]=temp;}deal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqz ztime,N);Print(p,arrivetime,servicetime,starttime,finishtime,zztime,dq zztime,N);}int main(){ int N;printf("短功课优先调度算法\n");printf("input the process's number:\n");scanf("%d",&N);input(a,N);sjf *b=a;sjf *c=a;sjff(b,N);system("PAUSE");}4.运转结果5.心得体会课程设计结束了，在此次的课程设计中不但检验了我所进修的常识，也培养了我如何去做一件事情，又如何完成一件事情的能力.通过模拟进程的调度成绩，更加深了我对于操纵零碎理论的理解，在本人的动手操纵过程中，能够体会成功的喜悦和碰到成绩本人解决的能力，对于我来说是一次提高，让本人多多的在实践中可以加深对理论的理解，也让我明白了当前应当如何更好，更高效的进修，在当前，我会更加努力.。
短作业优先调度算法（SJF）
短作业优先调度算法（SJF）假设有n项作业位于就绪队列中，这些作业的提交时间⽤数组requestTimes按照提交时间的先后顺序存储，对应的作业服务时间（持续时间）⽤数组durations存储。
采⽤SJF算法，计算n项作业的平均等待时间。
当存在多个相同长度的短作业时，按照提交时间的先后顺序进⾏调度。
假设0<= n <= 100。
求出所有作业的平均等待时间。
函数原型：void minWaitingTime(int requestTimes[],int durations[],int n)测试⽤例：输⼊40 2 4 57 4 1 4输出：4.01 #include <stdio.h>2 #include <stdlib.h>3 #include <string.h>45#define MAX 0x7FFFFFFF67void minWaitingTime(int requestTimes[],int durations[],int n)8 {9int i,time,j,k;10float res;11int index,arriveTime,indextemp;12int *done = (int *)malloc(sizeof(int) * n); //表⽰作业是否执⾏过,1表⽰执⾏完毕,0表⽰未执⾏13int *wait = (int *)malloc(sizeof(int) * n); //表⽰等待时间14for(i = 0; i < n; ++i){15 wait[i] = 0;16 done[i] = 0;17 }1819 time = 0; //time表⽰总作业执⾏时间20for(i = 0; i < n; i++){21if(i == 0){ //执⾏第⼀个作业22 time += durations[i];23 done[i] = 1;24for(j = 1; j < n; j++){25if(requestTimes[j] < time)26 wait[j] = time - requestTimes[j];27 }28 }29else{30 index = GetMin(durations,done,n);31//判断是否有多个最短作业,如有选择其中先到达的32 arriveTime = requestTimes[index];33for(indextemp = index + 1; indextemp < n; indextemp++){34if(done[indextemp] == 0 && durations[indextemp] == durations[index] &&35 requestTimes[indextemp] < arriveTime)36 index = indextemp;37 }3839 time += durations[index];40 done[index] = 1;41//执⾏选出的最短作业，并更新其它作业的等待时间42for(indextemp = 0; indextemp < n && i < n-1; indextemp++)43if(done[indextemp] == 0 &&requestTimes[indextemp] < time)44 wait[indextemp] = time - requestTimes[indextemp];45 }46 }4748 res = 0.0;49for(i = 0; i < n; i++)50 res += wait[i];5152 printf("%f\n",res / n);5354 }55//每次取出服务时间最短且⽰执⾏过的作业56int GetMin(int durations[],int done[],int n)57 {58int i,j,min = MAX;59for(i = 0; i < n; i++)60if(durations[i] < min && done[i] == 0){61 min = durations[i];62 j = i;63 }64return j;65 }6667int main()68 {69int requestTimes[100];70int durations[100];71int i,n;72 scanf("%d",&n);73for(i = 0; i < n; i++)74 scanf("%d",&requestTimes[i]);75for(i = 0; i < n; i++)76 scanf("%d",&durations[i]);7778 minWaitingTime(requestTimes,durations,n); 7980 system("pause");81return0;82 }。
最短作业优先(抢占和非抢占)
最短作业优先（抢占和非抢占）一、流程图解析：在最开始，我们先创建若干进程，选择自动运行，则在运行完后，按顺序显示运行的结果。
同理，选择手动运行，那么就是最先选择最短的作业开始运行，其实当前进程并非一定在实际运行（改变自己的状态），只是一个虚拟的运行（虚拟最短作业优先运行算法），这时我们可以做其他的事情，在做事之前，先运行虚拟算法，依照最短作业优先去改变相关进程的状态（进程可能就没有实际运行过，被虚拟算法改变了状态（就绪、等待、终止）），在做完相关事情之后，再运行虚拟算法，确定是否要发生最短作业的优先抢占。
根据以上的运行结构，我们可以在这结构的基础上，人为地设置进程状态就是改变进程状态，这时就可以发生最短作业调度的抢占和非抢占式。
我们可以进入查看进程状态，看看运行的状况，也可以进入修改进程状态，修改相关进程状态让其发生最短作业的抢占，或者进入创建进程，创建一个新的进程，这是也有可能实现最短作业优先的抢占。
二、虚拟运行算法：从进程的结构分析，进程里面有状态，到达时间（取系统时间），结束时间（取系统时间），需要运行时间，已运行时间等，我们知道第一个最短作业运行的到达时间（开始运行的时间）就是创建的时间。
在一个进程运行终止时，要设好终止的时间、改变状态等属性，这时进行进程间信息交换，终止进程的时间交给下一个要运行的进程的到达时间，这样不断下去就可以运行到最后一个进程，当发生抢占调度时，也是以上的情况运行。
先在抢占之前，就运行虚拟算法，改变相关的进程状态，发生引起抢占的事的时候就可以利用抢占来进行进程的切换。
这样就能让CPU在有工作做时就不能空闲。
直到把所有在就绪队列的进程运行完，这是CPU可以休息了，如果在CPU休息时有进程从等待进入就绪，那么CPU就要继续开工。
当我们运行完第一批输入的进程，现在CPU在空转，我们又创建了新进程，这时新进程就在创建那一刻起开始运行了，因为新进程创建好就进入了就绪的状态。
实验 短作业优先进程调度算法模拟
1.写出你对给出的程序的理解，可以包括学到了那些程序设计的语法或方法，以及算法的设计思想。
2.写出实验指导中要求部分是如何实现的，
3.上述部分不能只是抄写代码，要有说明。
附录： 先来先服务进程调度模拟程序
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
printf("----------------------------------------------------------------------------------------------\n");
for(int i=0;i<N;i++)
{
printf(" %s %d %d %d %d \n",pcb[i].name,pcb[i].arrive_time,pcb[i].run_time,pcb[i].finish_time,pcb[i].zhouzhuan_time);
#include <conio.h>
#define N 5
struct PCB
{
char name[8];
int arrive_time;
int run_time;
int finish_time;
int zhouzhuan_time;
};
int total=0;
struct PCB pcb[N],temp;
output();
//运行第一个到达的进程得到它的完成时间、周转时间等,并设置为已访问
pcb[0].finish_time=pcb[0].arrive_time+pcb[0].run_time;
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
短作业优先算法例题
短作业优先算法（Shortest Job First Algorithm，SJF）是一种
资源调度算法，它以最短作业（或进程）的时间为基准来调度进程，
即将剩余未完成的进程中第一个就绪最短作业优先分配。
它可以用于
处理器调度、磁盘调度等多种资源控制。
SJF算法将所有等待的作业按照它们需要的运行时间从短到长的顺
序组成一个队列，当一个作业抵达后，它就被插入到队列中，在队列
的最前端则放置了需要最少运行时间的作业。
然后，当CPU由空闲变
成可用时，它就从队列的首元素开始选择作业来执行，即先加载最短
运行时间的作业，这样可以使整个系统更加有效地使用CPU，减少等待
时间和提高吞吐量。
总之，SJF算法的优点是显著减少了平均等待时间，但是它的缺点
也很明显：第一，要求系统具有对各作业运行时间的精确预测能力，
否则它无法正确排序；第二，有时候短作业也会受阻，因为它需要等
待更长作业的结束，这样就会增加空闲时间；第三，这种算法不能有
效地分配I/O资源。
下面为SJF算法例题：
假定系统中有4个作业A,B,C,D，它们的运行时间分别为3,3,2,4。
(1)如果采用先来先服务调度，则运行结果如下，平均周转时间为(12+7+4+4)/4=7.25
A -->
B -->
C --> D
时间： 0 3 6 8 12
(2)如果采用短作业优先算法，则运行结果如下，平均周转时间为(6+3+4+4)/4=4.5
C --> A --> B --> D
时间： 0 2 5 8 12。