短作业优先调度算法C语言实现
先来先服务和优先数调度算法c语言

先来先服务和优先数调度算法c语言先来先服务和优先数调度算法c语言一、前言操作系统中的进程调度是指在多道程序环境下,按照一定的规则从就绪队列中选择一个进程,将CPU分配给它运行。
常用的进程调度算法有先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)等。
本文将介绍两种常见的进程调度算法:先来先服务和优先数调度算法,并给出相应的C语言实现。
二、先来先服务算法1. 算法原理FCFS即First Come First Served,也称为FIFO(First In First Out),是一种非抢占式的进程调度算法。
按照任务到达时间的顺序进行处理,即谁先到达谁就被处理。
2. 算法流程(1)按照任务到达时间排序;(2)依次执行每个任务,直至所有任务都完成。
3. C语言实现下面是一个简单的FCFS程序:```c#include <stdio.h>struct process {int pid; // 进程IDint arrival_time; // 到达时间int burst_time; // 执行时间int waiting_time; // 等待时间};int main() {struct process p[10];int n, i, j;float avg_waiting_time = 0;printf("请输入进程数:");scanf("%d", &n);for (i = 0; i < n; i++) {printf("请输入第%d个进程的信息:\n", i + 1); printf("进程ID:");scanf("%d", &p[i].pid);printf("到达时间:");scanf("%d", &p[i].arrival_time);printf("执行时间:");scanf("%d", &p[i].burst_time);}for (i = 0; i < n; i++) {for (j = 0; j < i; j++) {if (p[j].arrival_time > p[j + 1].arrival_time) { struct process temp = p[j];p[j] = p[j + 1];p[j + 1] = temp;}}}int current_time = p[0].arrival_time;for (i = 0; i < n; i++) {if (current_time < p[i].arrival_time) {current_time = p[i].arrival_time;}p[i].waiting_time = current_time - p[i].arrival_time;current_time += p[i].burst_time;}printf("进程ID\t到达时间\t执行时间\t等待时间\n");for (i = 0; i < n; i++) {printf("%d\t%d\t%d\t%d\n", p[i].pid, p[i].arrival_time, p[i].burst_time, p[i].waiting_time);avg_waiting_time += (float)p[i].waiting_time / n;}printf("平均等待时间:%f\n", avg_waiting_time);return 0;}```三、优先数调度算法1. 算法原理优先数调度算法是一种非抢占式的进程调度算法。
作业调度(算法(c语言版))

作业调度算法设计思路:1.每个进程有一个作业控制块(JCB)表示。
进程控制块包含如下信息:作业号、作业到达时间、作业要求服务时间、等待时间、开始运行时间、结束运行时间、周转时间、带权周转时间、优先权和是否已经完成;2. 设置一个作业数量num;3.由于在单道批处理系统中,作业一投入运行,它就占有计算机的一切资源直到作业完成为止,因此调度作业时不必考虑它所需要的资源是否得到满足,它所占用的CPU时限等因素;4.分别采用先来先服务(FCFS),最短作业优先(SJF)、响应比高者优先(HRN)的调度算法对输入进程进行调度;5.先来先服务(FCFS)对先来的作业优先处理;6.最短作业优先(SJF)对已就绪作业进行短程序优先服务;7.响应比=(等待时间+需要服务时间)/需要服务时间,响应比高者优先(HRN)是对已就绪作业进行响应比高者优先服务,以免一些程序长时间不能被执行;8.对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间,以及这组作业的平均周转时间及带权平均周转时间,以比较各种算法的优缺点。
#include <stdio.h>#include <string.h>#include <conio.h>/*conio.h是一个包含一些字符处理函数的头文件,如getch(),getch()是无显示的从键盘接收一个字符,有显示的接收是getchar()*/typedef char string[10]; /*//定义string为含有10个字符元素的字符数组类型*/ struct task {string name; /*作业号*/int arrTime; /* 作业到达时间*/int serTime; /*作业要求服务时间*/int waiTime; /*等待时间*/int begTime; /*开始运行时间*/int finTime; /*结束运行时间*/int turTime; /*周转时间*/int wTuTime; /*带权周转时间*/int priority;/*优先权*/int finish;/*是否已经完成*/}JCB[5];int num;void input(){int i;system("cls");printf("\nPlease input task number: ");scanf("%d", &num);for(i=0;i<num;i++){printf("\nPlease input task NO.%d:\n",i);printf(" The name of task: ");scanf("%s",JCB[i].name);printf(" The time arrive: ");scanf("%d",&JCB[i].arrTime);printf(" The time need: ");scanf("%d",&JCB[i].serTime);JCB[i].priority = 0;JCB[i].finish =0;}}int FCFS(){int current;int i,j;for(i=0; i<num; i++){if(!JCB[i].finish){current=i; /* 找到第一个还没完成的作业*/break;}}for( j=i; j<num; j++) /* 和后面的作业比较*/{if(!JCB[j].finish && JCB[j].arrTime<JCB[current].arrTime){current=j; /*找出先来的未完成作业*/}}return current; /* 返回当前作业*/}int SJF(int pre){int current,i,j;for(i=0; i<num; i++){if(!JCB[i].finish){current=i; /*找到第一个还没完成的作业*/break;}}for(j=i; j<num; j++) /* 和后面的作业比较*/{if( !JCB[j].finish) /* 还没完成(运行)*/{if(JCB[current].arrTime<=JCB[pre].finTime)/*如果作业在上一个作业完成之前到达*/{if(JCB[j].arrTime<=JCB[pre].finTime && JCB[j].serTime<JCB[current].serTime )current=j; /* 找出到达时间在上一个作业完成之前,服务时间比较小的未完成作业*/}else /*如果作业是在上一个作业完成之后到达*/{if(JCB[j].arrTime<JCB[current].arrTime)current=j; /*找出比较早到达的一个*/if(JCB[j].arrTime==JCB[current].arrTime) /*如果同时到达*/if(JCB[j].serTime<JCB[current].serTime)current=j; /*找出服务时间比较短的一个*/}}}return current; /*返回当前作业*/}int HRN(int pre){int current=1,i,j;/* 优先权=(等待时间+服务时间)/服务时间*/for(i=0; i<num; i++){JCB[i].waiTime=JCB[pre].finTime-JCB[i].arrTime; /*等待时间=上一个作业的完成时间-到达时间*/JCB[i].priority=(JCB[i].waiTime+JCB[i].serTime)/JCB[i].serTime;}for(i=0; i<num; i++){if(!JCB[i].finish){current=i; /*找到第一个还没完成的作业*/break;}}for( j=i; j<num; j++) /*和后面的作业比较*/{if( !JCB[j].finish) /* 还没完成(运行)*/{if(JCB[current].arrTime<=JCB[pre].finTime) /*如果作业在上一个作业完成之前到达*/{if(JCB[j].arrTime<=JCB[pre].finTime && JCB[j].priority>JCB[current].priority )current=j;/* 找出到达时间在上一个作业完成之前,优先权高的作业*/}else /* 如果作业是在上一个作业完成之后到达*/{if(JCB[j].arrTime<JCB[current].arrTime)current=j; /* 找出比较早到达的一个*/if(JCB[j].arrTime==JCB[current].arrTime) /* 如果同时到达*/if(JCB[j].priority>JCB[current].priority)current=j; /*找出服务时间比较短的一个*/}}}return current;/*返回当前作业*/}void runing(int i, int times, int pre, int staTime, int endTime){if(times==0){JCB[i].begTime=JCB[i].arrTime;JCB[i].finTime=JCB[i].begTime+JCB[i].serTime;JCB[i].turTime=JCB[i].serTime;JCB[i].wTuTime=1.0;staTime=JCB[i].begTime;}else{if(JCB[i].arrTime>JCB[pre].finTime)JCB[i].begTime=JCB[i].arrTime;elseJCB[i].begTime=JCB[pre].finTime;JCB[i].finTime=JCB[i].begTime+JCB[i].serTime;JCB[i].turTime=JCB[i].finTime-JCB[i].arrTime;JCB[i].wTuTime=JCB[i].turTime/JCB[i].serTime;}if(times==num-1)endTime=JCB[i].finTime;JCB[i].finish=1;}void print(int i,int times){if(times==0){printf(" name arrTime serTime begTime finTime turTime wTuTime\n");}printf("%9s%9d%9d%9d%9d%9df%9df\n",JCB[i].name,JCB[i].arrTime,JCB[i].serTime,JCB[i].begTime,JCB[i].finTime,JCB[i].turTime,JCB[i].wTuTime);}void check( ){int i;int staTime, endTime, sumTurTime=0.0, sumWTuTime=0.0, aveTurTime, aveWTuTime;int current=0, times=0, pre=0;JCB[pre].finTime=0;printf("\n-- FCFS -----------------------------------------------------------------\n");for(times=0; times<num; times++){current=FCFS();runing(current, times, pre, staTime, endTime);print(current, times);pre=current;}for(i=0; i<num; i++){sumTurTime+=JCB[i].turTime;sumWTuTime+=JCB[i].wTuTime;}aveTurTime=sumTurTime/num;aveWTuTime=sumWTuTime/num;printf("(total) %9.2f%9.2f%9.2f%9.2f\n",staTime,endTime,aveTurTime,aveWTuTime);printf("-------------------------------------------------------------------------\n");for(i=0; i<num; i++){JCB[i].finish=0;}staTime, endTime, sumTurTime=0.0, sumWTuTime=0.0, aveTurTime, aveWTuTime;current=0; times=0; pre=0;JCB[pre].finTime=0;printf("\n-- SJF ------------------------------------------------------------------\n");for(times=0; times<num; times++){current=SJF(pre);runing(current, times, pre, staTime, endTime);print(current, times);pre=current;}for(i=0; i<num; i++){sumTurTime+=JCB[i].turTime;sumWTuTime+=JCB[i].wTuTime;}aveTurTime=sumTurTime/num;aveWTuTime=sumWTuTime/num;printf("(total) %9d%9d%9d%9d\n",staTime,endTime,aveTurTime,av eWTuTime);printf("-------------------------------------------------------------------------\n");for(i=0; i<num; i++){JCB[i].finish=0;}staTime, endTime, sumTurTime=0.0, sumWTuTime=0.0, aveTurTime, aveWTuTime;current=0; times=0; pre=0;JCB[pre].finTime=0;printf("\n-- HRN ------------------------------------------------------------------\n");for(times=0; times<num; times++){current=HRN(pre);runing(current, times, pre, staTime, endTime);print(current, times);pre=current;}for(i=0; i<num; i++){sumTurTime+=JCB[i].turTime;sumWTuTime+=JCB[i].wTuTime;}aveTurTime=sumTurTime/num;aveWTuTime=sumWTuTime/num;printf("(total) %9d%9d%9d f%9df\n",staTime,endTime,aveTurTime,aveWTuTime);printf("-------------------------------------------------------------------------\n");}void main(){char again;do {system("cls"); /*清屏*/printf("please input 4 groups of datas:\n");input();check();printf("Continue...(Y/N): ");do{again = getch();}while(again!='Y' && again!='y' && again!='N' && again!='n');}while(again=='Y' || again=='y');}。
短作业优先调度算法C语言实现

#include <stdio.h>struct sjf //定义进程的结构体{char name[10]; //进程名float arrivetime; //到达时间float servicetime; //服务时间float starttime; //开始时间float finishtime; //完成时间float zztime; //周转时间float dqzztime; //带权周转时间};sjf b[100]; //定义短作业优先算法进程的最大数量void Sinput(sjf *p,int N) //输入函数{int i;printf("输入进程的名称、到达时间、服务时间:(例如: x 0 100)\n");for(i=0;i<=N-1;i++){printf("输入第%d进程的名称、到达时间、服务时间:",i+1);scanf("%s%f%f",&p[i].name,&p[i].arrivetime,&p[i].servicetime);}}//输出函数void SPrint(sjf *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N){int k;printf("\n执行顺序:\n");printf("%s",p[0].name);for(k=1;k<N;k++){printf("-%s",p[k].name);}printf("\n进程名\tarrive\tservice\tstart\tfinish\tzz\tdqzz\n");for(k=0;k<=N-1;k++){printf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n\n",p[k].name,p[k].arrivetime,p[k].ser vicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime);}}void Ssort(sjf *p,int N) //按短作业优先算法排序{for(int i=1;i<=N-1;i++)for(int j=1;j<=i;j++)if(p[i].servicetime<p[j].servicetime){sjf temp;temp=p[i];p[i]=p[j];p[j]=temp;}}//运行结果void Sdeal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N){int k;for(k=0;k<=N-1;k++){if(k==0){p[k].starttime=p[k].arrivetime;p[k].finishtime=p[k].arrivetime+p[k].servicetime;}else{p[k].starttime=p[k-1].finishtime; //开始时间=前一个进程的完成时间p[k].finishtime=p[k-1].finishtime+p[k].servicetime; //结束时间=前一个进程的完成时间+现在进程的服务时间}}for(k=0;k<=N-1;k++){p[k].zztime=p[k].finishtime-p[k].arrivetime; //周转时间=完成时间-到达时间p[k].dqzztime=p[k].zztime/p[k].servicetime; //带权周转时间=周转时间/服务时间}}void SJF(sjf *p,int N){float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;Ssort(p,N);Sdeal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);SPrint(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);}void main() //主函数{ int M;printf("------------短作业优先调度算法-----------\n");printf("输入进程数:");scanf("%d",&M);Sinput(b,M);SJF(b,M);}。
先来先服务,短作业优先,高响应比进程调度算法的实现

先来先服务,短作业优先,⾼响应⽐进程调度算法的实现⼀、实验内容编程实现先来先服务算法、短作业优先算法、⾼响应⽐算法,并求出每个作业的完成时间、周转时间、带权周转时间,及平均周转时间、平均带权周转时间。
⼆、实验要求1.任选⼀种⾼级语⾔实现;2.选择FCFS、SJF、HRRN调度算法;3.能够输⼊进程的基本信息,如进程名、提交时间、预估运⾏时间等;4.根据选择的调度算法显⽰进程调度顺序;5.显⽰完成调度后每个进程的开始时间、完成时间呢、周转时间,带权周转时间;6.计算平均周转时间和平均带权周转时间;三、实验过程1、设计思想FCFS算法对提交时间进⾏排序,按提交时间从⼩到⼤的顺序调度,SJF算法从第⼆个进程开始计算找出当前处在就绪等待队列的进程,并找出其中运⾏时间最短的作为下次调度的进程,HRRN算法从第⼆个进程开始计算找出当前处在就绪等待队列的进程,并找出其中响应⽐最⼩的作为下次调度的进程2.运⾏结果四、实验代码#include<iostream>#include<Windows.h>#include<stdio.h>#include<stdlib.h>#include <time.h>#define N 5using namespace std;struct Mystruct{float arrivetime;float runtime;float starttime;float waittime;float endtime;float turnaroundtime;float rightturnaroundtime;}Thread[N];void sort(struct Mystruct Thread[]) {//按进程到达时间排序for (int i = 0; i < N; i++) {for (int j = 0; j < N - 1; j++) {if (Thread[j].arrivetime > Thread[j + 1].arrivetime) {float t1 = Thread[j + 1].arrivetime;Thread[j + 1].arrivetime = Thread[j].arrivetime;Thread[j].arrivetime = t1;float t2 = Thread[j + 1].runtime;Thread[j + 1].runtime = Thread[j].runtime;Thread[j].runtime = t2;}}}}float JRR(float i, float j, float k) {//计算响应⽐float s = (i - j + k) / k;//cout << i << " " << j << " " << k << "响应⽐" << s << endl;return s;}void RRsort(int i) {//找出最⼩响应⽐进程的下标与下次要运⾏的进程交换次序,使处在就绪状态响应⽐最⼩的进程下次运⾏int next = 0;float min = 30;for (int j = i + 1; j < N; j++){if (Thread[j].arrivetime <= Thread[i].endtime) {float RR;// cout << Thread[i].endtime << endl;if (i != 4)RR = JRR(Thread[i].endtime, Thread[j].arrivetime, Thread[j].runtime);if (RR < min)//找出最⼩响应⽐{min = RR;next = j;}}}Mystruct temp;temp = Thread[i + 1];Thread[i + 1] = Thread[next];Thread[next] = temp;}void FCFS() {int count = 0;cout << "==========================先来先服务算法调度==========================" << endl;sort(Thread);float avewaittime = 0,aveturnaroundtime=0,averightturnaroundtime=0;cout << "作业号" << "\t" << "提交时间" << "\t" << "运⾏时间" << "\t" << "开始时间" << "\t" << "等待时间" << "\t" << "完成时间"<<"\t" << "周转时间" << " \t" << "带权周转时间" << endl;for (int i = 0; i < N; i++){count++;if (count == 1)Thread[i].starttime = Thread[i].arrivetime; else Thread[i].starttime=Thread[i-1].starttime+Thread[i-1].runtime;if (Thread[i].starttime<Thread[i].arrivetime){Thread[i].starttime = Thread[i].arrivetime;}Thread[i].endtime = Thread[i].starttime + Thread[i].runtime;Thread[i].waittime = Thread[i].starttime - Thread[i].arrivetime;Thread[i].turnaroundtime = Thread[i].endtime - Thread[i].arrivetime;Thread[i].rightturnaroundtime = Thread[i].turnaroundtime / Thread[i].runtime;avewaittime += Thread[i].waittime; aveturnaroundtime += Thread[i].turnaroundtime; averightturnaroundtime += Thread[i].rightturnaroundtime;cout <<count<<"\t" <<Thread[i].arrivetime << "\t\t" << Thread[i].runtime << "\t\t" << Thread[i].starttime << "\t\t" << Thread[i].waittime << "\t\t" << Thr ead[i].endtime << "\t\t" << Thread[i].turnaroundtime << "\t\t" << Thread[i].rightturnaroundtime << endl;}cout << "平均等待时间:" << avewaittime / N << "\t" << "平均周转时间:" << aveturnaroundtime/N << "\t" << "平均带权周转时间:" << averightturna roundtime / N << endl;}void SJF(struct Mystruct Thread[]){float avewaittime = 0, aveturnaroundtime = 0, averightturnaroundtime = 0;for (int m = 0; m < N - 1; m++){if (m == 0)Thread[m].endtime = Thread[m].arrivetime + Thread[m].runtime;else{if (Thread[m - 1].endtime >= Thread[m].arrivetime){Thread[m].starttime = Thread[m - 1].endtime;}else{Thread[m].starttime = Thread[m].arrivetime;}Thread[m].endtime = Thread[m].starttime + Thread[m].runtime;}int i = 0;for (int n = m + 1; n <= N - 1; n++){if (Thread[n].arrivetime <= Thread[m].endtime)i++;}//按运⾏时间排序float min = Thread[m + 1].runtime;int next = m + 1;//m+1=nfor (int k = m + 1; k < m + i; k++){if (Thread[k + 1].runtime < min){min = Thread[k + 1].runtime;next = k + 1;}}// cout << min << endl;Mystruct temp;temp = Thread[m + 1];Thread[m + 1] = Thread[next];Thread[next] = temp;}int count = 0;cout << "==========================短作业优先算法调度==========================" << endl;cout << "作业号" << "\t" << "提交时间" << "\t" << "运⾏时间" << "\t" << "开始时间" << "\t" << "等待时间" << "\t" << "完成时间" << "\t" << "周转时间" << " \t" << "带权周转时间" << endl;for (int i = 0; i < N; i++){count++;if (count == 1){Thread[i].starttime = Thread[i].arrivetime;Thread[i].endtime = Thread[i].starttime + Thread[i].runtime;Thread[i].waittime = Thread[i].starttime - Thread[i].arrivetime;Thread[i].turnaroundtime = Thread[i].endtime - Thread[i].arrivetime;Thread[i].rightturnaroundtime = Thread[i].turnaroundtime / Thread[i].runtime;cout << count << "\t" << Thread[i].arrivetime << "\t\t" << Thread[i].runtime << "\t\t" << Thread[i].starttime << "\t\t" << Thread[i].waittime << "\t\t" << Thread[i].endtime << "\t\t" << Thread[i].turnaroundtime << "\t\t" << Thread[i].rightturnaroundtime << endl;}else{Thread[i].starttime = Thread[i - 1].starttime + Thread[i - 1].runtime;if (Thread[i].starttime < Thread[i].arrivetime){Thread[i].starttime = Thread[i].arrivetime;}Thread[i].endtime = Thread[i].starttime + Thread[i].runtime;Thread[i].waittime = Thread[i].starttime - Thread[i].arrivetime;Thread[i].turnaroundtime = Thread[i].endtime - Thread[i].arrivetime;Thread[i].rightturnaroundtime = Thread[i].turnaroundtime / Thread[i].runtime;avewaittime += Thread[i].waittime; aveturnaroundtime += Thread[i].turnaroundtime; averightturnaroundtime += Thread[i].rightturnaroundtime;cout << count << "\t" << Thread[i].arrivetime << "\t\t" << Thread[i].runtime << "\t\t" << Thread[i].starttime << "\t\t" << Thread[i].waittime << "\t\t" << Thread[i].endtime << "\t\t" << Thread[i].turnaroundtime << "\t\t" << Thread[i].rightturnaroundtime << endl;}}cout << "平均等待时间:" << avewaittime / N << "\t" << "平均周转时间:" << aveturnaroundtime / N << "\t" << "平均带权周转时间:" << averightturn aroundtime / N << endl;}void HRRN(struct Mystruct Thread[]){int count = 0;float avewaittime = 0, aveturnaroundtime = 0, averightturnaroundtime = 0;cout << "==========================⾼响应⽐算法调度==========================" << endl;cout << "作业号" << "\t" << "提交时间" << "\t" << "运⾏时间" << "\t" << "开始时间" << "\t" << "等待时间" << "\t" << "完成时间" << "\t" << "周转时间" << "\t" << "带权周转时间" << endl;for (int i = 0; i < N; i++){count++;if (count == 1)Thread[i].starttime = Thread[i].arrivetime; else Thread[i].starttime = Thread[i - 1].starttime + Thread[i - 1].runtime;if (Thread[i].starttime < Thread[i].arrivetime){Thread[i].starttime = Thread[i].arrivetime;}Thread[i].endtime = Thread[i].starttime + Thread[i].runtime;RRsort(i);//找出处在等待的最⼩响应⽐的进程下次运⾏Thread[i].waittime = Thread[i].starttime - Thread[i].arrivetime;Thread[i].turnaroundtime = Thread[i].endtime - Thread[i].arrivetime;Thread[i].rightturnaroundtime = Thread[i].turnaroundtime / Thread[i].runtime;avewaittime += Thread[i].waittime; aveturnaroundtime += Thread[i].turnaroundtime; averightturnaroundtime += Thread[i].rightturnaroundtime;cout << count << "\t" << Thread[i].arrivetime << "\t\t" << Thread[i].runtime << "\t\t" << Thread[i].starttime << "\t\t" << Thread[i].waittime << "\t\t" << T hread[i].endtime << "\t\t" << Thread[i].turnaroundtime << "\t\t" << Thread[i].rightturnaroundtime << endl;}cout << "平均等待时间:" << avewaittime / N << "\t" << "平均周转时间:" << aveturnaroundtime / N << "\t" << "平均带权周转时间:" << averightturn aroundtime / N << endl;}int main() {srand((int)time(0));for (int i = 0; i < N; i++) {Thread[i].arrivetime = rand() % 20;Thread[i].runtime = rand() % 20 + 1;}FCFS();SJF(Thread);HRRN(Thread);return 0;}五、实验总结通过本次实验我更加了解了先来先服务算法、短作业优先算法、⾼响应⽐算法,通过带权周转时间的计算知道了FCFS算法对长作业有利,对短作业不利,SJF算法对短作业有利,对长作业不利,在所有进程同时可运⾏是采⽤SJF算法的平均等待时间、平均周转时间最少。
c语言实时调度算法

c语言实时调度算法
C语言中常用的实时调度算法有以下几种:
1. 先来先服务(FCFS)调度算法:按照任务到达的顺序来进行调度,先到达的任务先执行。
2. 最短作业优先(SJF)调度算法:根据任务的执行时间进行排序,执行时间最短的任务先执行。
3. 优先级调度算法:给每个任务分配一个优先级,优先级越高的任务优先执行。
4. 时间片轮转(Round Robin)调度算法:将任务按照先后顺序放入一个就绪队列中,每个任务执行一个时间片的时间(一般是一个固定的时间),然后切换到下一个任务,直到所有任务执行完毕。
5. 最早截止时间优先(EDF)调度算法:每个任务都有一个最后期限,按照最后期限的先后顺序进行调度,最后期限最早的任务优先执行。
6. 最高响应比优先(HRRN)调度算法:计算每个任务的响应比,响应比等于(等待时间 + 执行时间)/ 执行时间,响应比最高的任务优先执行。
这些调度算法都可以在C语言中实现,但需要注意实时系统的特殊需求,如任务的截止时间、优先级等。
进程调度实验报告

进程调度实验报告一、实验目的。
本实验旨在通过对进程调度算法的模拟和实验,加深学生对进程调度原理的理解,掌握各种进程调度算法的特点和应用场景,提高学生的实际操作能力和分析问题的能力。
二、实验环境。
本次实验使用了C语言编程语言,通过模拟实现了先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)和多级反馈队列(MFQ)四种进程调度算法。
三、实验过程。
1. 先来先服务(FCFS)调度算法。
先来先服务调度算法是一种非抢占式的调度算法,按照进程到达的先后顺序进行调度。
在本次实验中,我们通过模拟多个进程到达并排队等待CPU执行,观察其平均等待时间和平均周转时间。
实验结果表明,先来先服务调度算法适用于作业长度差异较大的情况,但容易产生“饥饿”现象。
2. 最短作业优先(SJF)调度算法。
最短作业优先调度算法是一种非抢占式的调度算法,按照作业执行时间的长短进行调度。
在本次实验中,我们通过模拟多个作业的执行时间,观察其平均等待时间和平均周转时间。
实验结果表明,最短作业优先调度算法能够最大程度地减少平均等待时间,但可能会导致长作业被“饿死”。
3. 时间片轮转(RR)调度算法。
时间片轮转调度算法是一种抢占式的调度算法,每个进程被分配一个时间片,当时间片用完后,该进程被放到队尾等待。
在本次实验中,我们通过模拟多个进程的执行和时间片的调度,观察其平均等待时间和平均周转时间。
实验结果表明,时间片轮转调度算法能够保证每个进程都能得到一定的执行时间,但可能会导致上下文切换频繁。
4. 多级反馈队列(MFQ)调度算法。
多级反馈队列调度算法是一种综合性的调度算法,根据进程的优先级和执行时间进行动态调整。
在本次实验中,我们通过模拟多个进程的执行和不同优先级队列的调度,观察其平均等待时间和平均周转时间。
实验结果表明,多级反馈队列调度算法能够兼顾短作业和长作业,提高了系统的整体性能。
四、实验总结。
通过本次实验,我们深入理解了不同进程调度算法的特点和适用场景。
作业调度算法之短作业优先调度算法和先来先服务调度算法

作业调度算法之短作业优先调度算法和先来先服务调度算法假设有四个作业,他们的提交、运⾏时间如下表所⽰。
请回答下列问题:
(1)若采⽤短作业优先调度算法,求作业运⾏顺序和平均带权周转时间为多少?
(2)若采⽤先来先服务调度算法,求作业运⾏顺序和平均带权周转时间为多少?
作业号到达时间运⾏时间
18.0 2.0
28.30.5
38.50.4
48.70.1
解:
(1)短作业优先调度算法,作业运⾏顺序:4,3,2,1
(2)先来先服务调度算法,作业运⾏顺序:1,2,3,4
作业号1234
到达时间8.08.38.58.7
运⾏时间 2.00.50.40.1
短作业优先调度算法
完成时刻11.79.79.28.8周转时间 3.7 1.40.70.1带权周转时间 1.85 1.751平均带全周转时间 1.85
先来先服务调度算法
完成时刻1010.510.911周转时间2 2.2 2.4 2.3带权周转时间1 4.4623平均带全周转时间8.6
注:周转时间= 完成时刻—到达时刻带权周转时间= 周转时间/运⾏时间。
先来先服务调度和最短作业优先调度算法实验报告

先来先服务调度和最短作业优先调度算法实验报告实验报告一、实验目的本实验旨在通过编写代码实现先来先服务调度算法和最短作业优先调度算法,以深入理解和掌握这两种调度算法的原理和实现方法。
二、实验方法和原理1.先来先服务调度算法(FCFS)2.最短作业优先调度算法(SJF)最短作业优先调度算法是根据作业所需的运行时间进行调度的。
当一个作业到达并获得CPU后,系统会选择剩余运行时间最短的作业进行处理,这样可以最大化地提高系统的吞吐量。
三、实验过程与结果1.先来先服务调度算法的实现我们先定义一个作业类Job,其中包含作业名称、到达时间和运行时间等属性。
首先根据到达时间对作业队列进行排序,然后按照顺序执行作业,记录每个作业的开始时间、结束时间和周转时间等指标。
下面是先来先服务调度算法的代码实现部分:```pythonclass Job: = namedef fcfs_scheduler(jobs):for job in sorted_jobs:#创建作业队列jobs =Job("Job1", 0, 3),Job("Job2", 1, 4),Job("Job3", 2, 2),Job("Job4", 4, 1)#调度作业fcfs_scheduler(jobs)#输出结果for job in jobs:```运行以上代码,会得到作业的开始时间、结束时间和周转时间等信息。
2.最短作业优先调度算法的实现最短作业优先调度算法需要知道每个作业的运行时间,而这个信息在实际情况中是未知的。
因此,我们可以先按到达时间对作业队列进行排序,然后在每个时间片中选择剩余运行时间最短的作业进行执行。
下面是最短作业优先调度算法的代码实现部分:```pythondef sjf_scheduler(jobs):while True:if not remaining_jobs:break#创建作业队列jobs =Job("Job1", 0, 3),Job("Job2", 1, 4),Job("Job3", 2, 2),Job("Job4", 4, 1)#调度作业sjf_scheduler(jobs)#输出结果for job in jobs:```运行以上代码,会得到相应的作业调度结果。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
#include <stdio.h>
struct sjf //定义进程的结构体
{
char name[10]; //进程名
float arrivetime; //到达时间
float servicetime; //服务时间
float starttime; //开始时间
float finishtime; //完成时间
float zztime; //周转时间
float dqzztime; //带权周转时间
};
sjf b[100]; //定义短作业优先算法进程的最大数量
void Sinput(sjf *p,int N) //输入函数
{
int i;
printf("输入进程的名称、到达时间、服务时间:(例如: x 0 100)\n");
for(i=0;i<=N-1;i++)
{
printf("输入第%d进程的名称、到达时间、服务时间:",i+1);
scanf("%s%f%f",&p[i].name,&p[i].arrivetime,&p[i].servicetime);
}
}
//输出函数
void SPrint(sjf *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N)
{
int k;
printf("\n执行顺序:\n");
printf("%s",p[0].name);
for(k=1;k<N;k++)
{
printf("-%s",p[k].name);
}
printf("\n进程名\tarrive\tservice\tstart\tfinish\tzz\tdqzz\n");
for(k=0;k<=N-1;k++)
{
printf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n\n",p[k].name,p[k].arrivetime,p[k].ser vicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime);
}
}
void Ssort(sjf *p,int N) //按短作业优先算法排序
{
for(int i=1;i<=N-1;i++)
for(int j=1;j<=i;j++)
if(p[i].servicetime<p[j].servicetime)
{
sjf temp;
temp=p[i];
p[i]=p[j];
p[j]=temp;
}
}
//运行结果
void Sdeal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N)
{
int k;
for(k=0;k<=N-1;k++)
{
if(k==0)
{
p[k].starttime=p[k].arrivetime;
p[k].finishtime=p[k].arrivetime+p[k].servicetime;
}
else
{
p[k].starttime=p[k-1].finishtime; //开始时间=前一个进程的完成时间
p[k].finishtime=p[k-1].finishtime+p[k].servicetime; //结束时间=前一个进程的完成时间+现在进程的服务时间
}
}
for(k=0;k<=N-1;k++)
{
p[k].zztime=p[k].finishtime-p[k].arrivetime; //周转时间=完成时间-到达时间
p[k].dqzztime=p[k].zztime/p[k].servicetime; //带权周转时间=周转时间/服务时间}
}
void SJF(sjf *p,int N)
{
float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;
Ssort(p,N);
Sdeal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);
SPrint(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);
}
void main() //主函数
{ int M;
printf("------------短作业优先调度算法-----------\n");
printf("输入进程数:");
scanf("%d",&M);
Sinput(b,M);
SJF(b,M);
}。