短作业优先调度算法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:```运行以上代码,会得到相应的作业调度结果。
调度算法C语言实现

调度算法C语言实现调度算法是操作系统中的重要内容之一,它决定了进程在系统中的运行方式和顺序。
本文将介绍两种常见的调度算法,先来先服务(FCFS)和最短作业优先(SJF),并用C语言实现它们。
一、先来先服务(FCFS)调度算法先来先服务(FCFS)调度算法是最简单的调度算法之一、它按照进程到达的先后顺序进行调度,即谁先到达就先执行。
实现这个算法的关键是记录进程到达的顺序和每个进程的执行时间。
下面是一个用C语言实现先来先服务调度算法的示例程序:```c#include <stdio.h>//进程控制块结构体typedef structint pid; // 进程IDint arrivalTime; // 到达时间int burstTime; // 执行时间} Process;int maiint n; // 进程数量printf("请输入进程数量:");scanf("%d", &n);//输入每个进程的到达时间和执行时间Process process[n];for (int i = 0; i < n; i++)printf("请输入进程 %d 的到达时间和执行时间:", i);scanf("%d%d", &process[i].arrivalTime,&process[i].burstTime);process[i].pid = i;}//根据到达时间排序进程for (int i = 0; i < n - 1; i++)for (int j = i + 1; j < n; j++)if (process[i].arrivalTime > process[j].arrivalTime) Process temp = process[i];process[i] = process[j];process[j] = temp;}}}//计算平均等待时间和平均周转时间float totalWaitingTime = 0; // 总等待时间float totalTurnaroundTime = 0; // 总周转时间int currentTime = 0; // 当前时间for (int i = 0; i < n; i++)if (currentTime < process[i].arrivalTime)currentTime = process[i].arrivalTime;}totalWaitingTime += currentTime - process[i].arrivalTime;totalTurnaroundTime += (currentTime + process[i].burstTime) - process[i].arrivalTime;currentTime += process[i].burstTime;}//输出结果float avgWaitingTime = totalWaitingTime / n;float avgTurnaroundTime = totalTurnaroundTime / n;printf("平均等待时间:%f\n", avgWaitingTime);printf("平均周转时间:%f\n", avgTurnaroundTime);return 0;```以上程序实现了先来先服务(FCFS)调度算法,首先根据进程的到达时间排序,然后依次执行每个进程,并计算总等待时间和总周转时间。
实现作业调度算法先来先服务+最短作业+最短剩余时间

0956104 朱文君操作系统上机报告一、实验目的:1.学习处理器各种调度算法的基本思想;2.通过上机实习,编写程序实现处理器的调度加深对各种算法的理解。
二、实验内容:1.实验平台:Microsoft Visual C++ 6.0编程环境、Microsoft Office Word软件平台;2.用C语言编程实现处理器的调度算法:①先来先服务算法②最短作业优先算法③最短剩余时间优先算法;三、实验步骤:(一)先来先服务算法1.说明:先来先服务算法(First Come First Served,FCFS)按照作业进入系统后备作业队列的先后次序来挑选作业,先进入系统的作业将优先被挑选进入主存,创建用户进程,分配所需资源,然后,移入就绪队列。
2.算法实现:#include<stdio.h>void main(){int i,a,T=0,N,add;float sum=0;printf("输入进程数:");scanf("%d",&N);for(i=1;i<=N;i++){printf("\n第%d个进程所需的时间:",i);scanf("%d",&a);T=T+a;sum+=T;printf("\n是否有新的进程进入,输入新的进程数:");scanf("%d",&add);N=N+add;}printf("\n T=%f",sum/N);}3.运行结果演示:(二)最短作业优先算法1.说明:最短作业优先算法(Shortest Job First,SFJ)以进入系统的作业所要求的CPU运行时间的长短为标准,总是选取预计计算时间最短的作业投入运行。
2.算法实现:#include<stdio.h>int De_a(int x,int y,int a[]){int i;if(x==y)a[x]=0;else{for(i=x;i<y;i++){a[i]=a[i+1];}a[i]=0;}return 1;}void main(){int N,M,i,j,k,add,flag,a[1000]={0};float T=0.000,W=0.000,sum=0;printf("输入进程数:");scanf("%d",&N);for(i=1;i<=N;i++){printf("\n第%d个进程所需的时间:",i);scanf("%d",&a[i]);}M=N;for(i=1;i<=N;i++){a[0]=a[1];for(j=1;j<=M;j++){if(a[0]>=a[j]){a[0]=a[j];flag=j;}}T=T+(float)a[flag];sum+=T;W=W+(float)T/a[flag];printf(" %f ",W);De_a(flag,M,a);printf("\n是否有新的进程进入,输入新的进程数:");scanf("%d",&add);for(k=1;k<=add;k++){printf("\n第%d个进程所需的时间:",i);scanf("%d",&a[k+M-1]);}N=N+add;M=M+add-1;}printf("平均作业周转时间T=%f\n",sum/N);printf("平均带权作业周转时间W=%f\n",W/N);}3.运行结果演示:(三)最短剩余时间优先算法1.说明:最短剩余时间优先算法(Shortest Remaining Time First,SRTF)即当前某进程/线程正在运行,如果有新进程/线程移入就绪队列,若它所需要的CPU运行时间比当前运行进程/线程所需要的剩余CPU时间还短,抢占式最短作业优先算法强行剥夺当前执行者的控制权,调度新进程/线程执行。
【操作系统】先来先服务和短作业优先算法(C语言实现)

【操作系统】先来先服务和短作业优先算法(C语⾔实现)【操作系统】先来先服务算法和短作业优先算法实现介绍:1.先来先服务 (FCFS: first come first service)如果早就绪的进程排在就绪队列的前⾯,迟就绪的进程排在就绪队列的后⾯,那么先来先服务(FCFS: first come first service)总是把当前处于就绪队列之⾸的那个进程调度到运⾏状态。
也就说,它只考虑进程进⼊就绪队列的先后,⽽不考虑它的下⼀个CPU周期的长短及其他因素。
FCFS算法简单易⾏,是⼀种⾮抢占式策略,但性能却不⼤好。
简单来说,先来先服务就是那个进程到达时间最早,那么CPU就先处理哪个进程。
2.短作业优先(SJF, Shortest Job First)对预计执⾏时间短的作业(进程)优先分派处理机。
通常后来的短作业不抢先正在执⾏的作业。
也就是说,不但要考虑进程的到达时间,还要考虑进程需要运⾏的时间。
当⼀个进程正在运⾏时,假如有其他的进程到达,那么这些到达的进程就需要按照其需要运⾏的时间长短排序,运⾏时间短的在前,运⾏时间长的在后。
3.例⼦:4.运⾏截图1.先来先服务2.短作业优先5.话不多说,直接上代码。
第⼀次写,有很多不⾜的地⽅。
希望⼤家看到可以帮忙纠正⼀下,谢谢⼤家。
#include <stdio.h>#include <stdlib.h>#define MAX 10typedef struct PCB {int id,arrive_time,service_time,start_time,finish_time; //进程id、到达时间、服务时间、开始时间、完成时间float zhouzhuan_time,daiquanzhouzhuan_time; //周转时间、带权周转时间。
只能说我的拼英。
emm,。
尴尬。
int status;}PCB;typedef enum {OK,ERROR}Status;typedef enum {FALSE,TRUE}Bool;typedef PCB datatype;typedef struct LinkQueue {int front;int rear;int length;datatype* base;}quene;int arrive[MAX]; // 记录每个作业的到达时间int service[MAX]; //记录每个作业的服务时间int num; //输⼊的进程个数quene init(){quene q_pcb;q_pcb.base = (datatype *)malloc(sizeof(datatype)*MAX);q_pcb.front = q_pcb.rear = 0;q_pcb.length = 0;return q_pcb;}Bool isFull(quene *q) {if ((q->rear + 1) % MAX == q->front) {return TRUE;}return FALSE;}Bool isEmpty(quene *q) {if (q->rear == q->front) {return TRUE;}return FALSE;}Status rudui(quene *q,datatype p){ //⼊队。
最短作业优先(抢占和非抢占)

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

操作系统实验报告实验一先来先服务FCFS和短作业优先SJF进程调度算法学号:班级::【实验题目】:先来先服务FCFS和短作业优先SJF进程调度算法【实验目的】通过这次实验,加深对进程概念的理解,进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。
【实验容】问题描述:设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。
假设有n 个进程分别在T1, …,T n时刻到达系统,它们需要的服务时间分别为S1, …,S n。
分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度,计算每个进程的完成时间,周转时间和带权周转时间,并且统计n个进程的平均周转时间和平均带权周转时间。
程序要求如下:1)进程个数n;每个进程的到达时间T1, … ,T n和服务时间S1, … ,S n;选择算法1-FCFS,2-SJF。
2)要求采用先来先服务FCFS和短作业优先SJF分别调度进程运行,计算每个进程的周转时间,带权周转时间,并且计算所有进程的平均周转时间,带权平均周转时间;3)输出:要求模拟整个调度过程,输出每个时刻的进程运行状态,如“时刻3:进程B开始运行”等等;4)输出:要求输出计算出来的每个进程的周转时间,带权周转时间,所有进程的平均周转时间,带权平均周转时间。
实现提示:用C++语言实现提示:1)程序中进程调度时间变量描述如下:static int MaxNum=100;int ArrivalTime[MaxNum];int ServiceTime[MaxNum];int FinishTime[MaxNum];int WholeTime[MaxNum];double WeightWholeTime[MaxNum];double AverageWT_FCFS,AverageWT_SJF;double AverageWWT_FCFS,AverageWWT_SJF;2)进程调度的实现过程如下:➢变量初始化;➢接收用户输入n,T1, … ,T n,S1, … ,S n;算法选择1-FCFS,2-SJF;➢按照选择算法进行进程调度,计算进程的完成时间、周转时间和带权周转时间;➢计算所有进程的平均周转时间和平均带权周转时间;➢按格式输出调度结果。
处理器调度算法c语言

处理器调度算法c语言一、概述处理器调度算法是操作系统中一个非常重要的问题。
在多任务操作系统中,有多个进程同时运行,而处理器只有一个,因此需要对进程进行调度,使得每个进程都能够得到适当的执行时间。
二、常见的处理器调度算法1. 先来先服务(FCFS)FCFS算法是最简单的调度算法之一。
它按照进程到达时间的先后顺序进行调度,即先到达的进程先执行。
这种算法容易实现,但可能会导致长作业等待时间过长。
2. 最短作业优先(SJF)SJF算法是根据每个进程所需的CPU时间来进行排序,并按照顺序进行调度。
这种算法可以减少平均等待时间和平均周转时间,并且可以最大限度地利用CPU资源。
3. 优先级调度优先级调度是根据每个进程的优先级来进行排序,并按照顺序进行调度。
这种算法可以确保高优先级进程得到更多的CPU时间,但可能会出现低优先级进程饥饿问题。
4. 时间片轮转(RR)RR算法将CPU分配给每个任务一定量的时间片,在该时间片内运行任务。
如果任务在该时间片内未完成,则将其放回队列尾部,并分配给下一个任务时间片。
这种算法可以确保公平性,并且可以避免长作业等待时间过长。
三、C语言中的处理器调度算法实现1. FCFS算法实现#include <stdio.h>int main(){int n, i, j;float avg_waiting_time = 0, avg_turnaround_time = 0;printf("Enter the number of processes: ");scanf("%d", &n);int burst_time[n], waiting_time[n], turnaround_time[n];printf("Enter the burst time for each process:\n");for(i=0; i<n; i++)scanf("%d", &burst_time[i]);waiting_time[0] = 0;turnaround_time[0] = burst_time[0];for(i=1; i<n; i++){waiting_time[i] = waiting_time[i-1] + burst_time[i-1];turnaround_time[i] = waiting_time[i] + burst_time[i];avg_waiting_time += waiting_time[i];avg_turnaround_time += turnaround_time[i];}avg_waiting_time /= n;avg_turnaround_time /= n;printf("\nProcess\tBurst Time\tWaiting Time\tTurnaround Time\n");for(i=0; i<n; i++)printf("P%d\t%d\t\t%d\t\t%d\n", i+1, burst_time[i], waiting_time[i], turnaround_time[i]);printf("\nAverage Waiting Time: %.2f\n", avg_waiting_ time);printf("Average Turnaround Time: %.2f\n", avg_turnaround_ time);return 0;}2. SJF算法实现#include <stdio.h>int main(){int n, i, j, temp;float avg_waiting_time = 0, avg_turnaround_time = 0; printf("Enter the number of processes: ");scanf("%d", &n);int burst_time[n], waiting_time[n], turnaround_time[n]; printf("Enter the burst time for each process:\n");for(i=0; i<n; i++)scanf("%d", &burst_time[i]);for(i=0; i<n-1; i++)for(j=i+1; j<n; j++)if(burst_time[i] > burst_time[j]){temp = burst_time[i];burst_time[i] = burst_time[j]; burst_time[j] = temp;}waiting_time[0] = 0;turnaround_time[0] = burst_time[0];for(i=1; i<n; i++){waiting_time[i] = waiting_time[i-1] + burst_time[i-1];turnaround_time[i] = waiting_time[i] + burst_time[i];avg_waiting_time += waiting_time[i];avg_turnaround_time += turnaround_time[i];}avg_waiting_time /= n;avg_turnaround_time /= n;printf("\nProcess\tBurst Time\tWaiting Time\tTurnaround Time\n");for(i=0; i<n; i++)printf("P%d\t%d\t\t%d\t\t%d\n", i+1, burst_time[i], waiting_time[i], turnaround_time[i]);printf("\nAverage Waiting Time: %.2f\n", avg_waiting_ time);printf("Average Turnaround Time: %.2f\n", avg_turnaround_ time);return 0;}3. 优先级调度算法实现#include <stdio.h>int main(){int n, i, j, temp;float avg_waiting_time = 0, avg_turnaround_time = 0;printf("Enter the number of processes: ");scanf("%d", &n);int burst_time[n], waiting_time[n], turnaround_time[n], priority[n];printf("Enter the burst time and priority for each process:\n"); for(i=0; i<n; i++)scanf("%d %d", &burst_time[i], &priority[i]);for(i=0; i<n-1; i++)for(j=i+1; j<n; j++)if(priority[i] > priority[j]){temp = priority[i];priority[i] = priority[j];priority[j] = temp;temp = burst_time[i];burst_time[i] = burst_time[j]; burst_time[j] = temp;}waiting_time[0] = 0;turnaround_time[0] = burst_time[0];for(i=1; i<n; i++){waiting_time[i] = waiting_time[i-1] + burst_time[i-1];turnaround_time[i] = waiting_time[i] + burst_time[i];avg_waiting_ time += waiting_ time[i];avg_turnaround_ time += turnaround_ time[i];}avg_waiting_ time /= n;avg_turnaround_ time /= n;printf("\nProcess\tBurst Time\tPriority\tWaiting Time\tTurnaround Time\n");for(i=0; i<n; i++)printf("P%d\t%d\t\t%d\t\t%d\t\t%d\n", i+1, burst_ time[i], priority[i], waiting_time[i], turnaround_time[i]);printf("\nAverage Waiting Time: %.2f\n", avg_waiting_ time);printf("Average Turnaround Time: %.2f\n", avg_turnaround _ time);return 0;}4. RR算法实现#include <stdio.h>int main(){int n, i, j, time_quantum;float avg_waiting_time = 0, avg_turnaround_time = 0;printf("Enter the number of processes: ");scanf("%d", &n);int burst_time[n], remaining_time[n], waiting_time[n], turnaround_time[n];printf("Enter the burst time for each process:\n");for(i=0; i<n; i++)scanf("%d", &burst_time[i]);printf("Enter the time quantum: ");scanf("%d", &time_quantum);for(i=0; i<n; i++)remaining_time[i] = burst_time[i];int t=0;while(1){int done = 1;for(i=0; i<n; i++){if(remaining_time[i] > 0){done = 0;if(remaining_ time[i] > time_ quantum){t += time_ quantum;remaining_ time[i] -= time_ quantum;}else{t += remaining _ time[i];waiting_time[i] = t - burst_time[i];remaining_ time[i] = 0;turnaround_ time[i] = waiting_time[i] + burst_time[i];avg_waiting_ time += waiting_ time[i];avg_turnaround _ time += turnaround_ time[i];}}}if(done == 1)break;}avg_waiting_ time /= n;avg_turnaround_ time /= n;printf("\nProcess\tBurst Time\tWaiting Time\tTurnaround Time\n");for(i=0; i<n; i++)printf("P%d\t%d\t\t%d\t\t%d\n", i+1, burst_time[i], waiting_time[i], turnaround_time[i]);printf("\nAverage Waiting Time: %.2f\n", avg_waiting_ time);printf("Average Turnaround Time: %.2f\n", avg_turnaround _ time);return 0;}四、总结以上是常见的处理器调度算法的C语言实现方式。
短作业优先算法

#include<stdio.h>#include <iostream>#include <iomanip>//精度设置必须包括的头文件#define MAX_JOBNUM 20using namespace std;typedef struct PCB_Node{char jobName;//作业名int arivTme;//到达时间int cpuTime;//cpu占用时间int startTime;int endTime;double needTime;//周转时间double prioTime;//带权周转时间char Tag;//'W'表示在等待队列,'R'表示在运行状态或者已经运行完成struct PCB_Node *next;}PCB;//以上定义进程控制块//找到下一个已提交最短作业PCB * searchJOB(PCB *P,int ClockTime){ //ClockTime表示当前最后一道作业的完成时间PCB *q,*qtr;int min=10000000;//q=P;for (qtr=P;qtr&&qtr->arivTme<=ClockTime;qtr=qtr->next){if(qtr->Tag=='W'){if (min>qtr->cpuTime){q=qtr;min=qtr->cpuTime;}}}return q}//短作业优先的算法描述void SJF(PCB job[],int N){int i;//把所有进程都串在一个事件链表中PCB *p,*head;head=(PCB *)malloc(sizeof(PCB_Node));head->next=NULL;for (i=N-1;i>=0;i--){if ((p=(PCB*) malloc(sizeof(PCB_Node)))==NULL){cerr<<"申请空间失败!";exit(0);}p->arivTme=job[i].arivTme;p->cpuTime=job[i].cpuTime;p->jobName=job[i].jobName;p->Tag='W';p->next=NULL;if(head->next==NULL){head->next=p;}else{p->next=head->next;head->next=p;}}PCB *ptr,*q,*qtr;// for (ptr=head->next;ptr;ptr=ptr->next)// {// cout<<" "<<left<<ptr->jobName// <<" "<<left<<ptr->arivTme// <<" "<<left<<ptr->cpuTime<<endl;//// }//假设事件是按提交的先后顺序串在一个链表中的;//对事件链表进行处理static int ClockTime=0;//记录当前模拟系统时间初始状态为ClockTime=0;cout<<"进程名到达时间服务时间开始时间完成时间周转时间带权周转时间\n";//第一个进入事件链表的作业开始运行ptr=head->next;ClockTime=ptr->arivTme;ptr->startTime=ClockTime;ptr->endTime=ptr->arivTme+ptr->cpuTime;ptr->needTime=ptr->endTime-ptr->arivTme;ptr->prioTime=(double) (ptr->needTime/ptr->cpuTime);for (qtr=ptr;qtr;qtr=qtr->next){if (qtr->jobName==ptr->jobName){qtr->Tag='R';}}ClockTime+=ptr->endTime;cout<<" "<<left<<ptr->jobName<<" "<<left<<ptr->arivTme<<" "<<left<<ptr->cpuTime<<" "<<left<<ptr->startTime<<" "<<left<<ptr->endTime<<" "<<left<<ptr->needTime<<" "<<left<<ptr->prioTime<<endl;int m=0;while (m<N-1){if(!(q=searchJOB(ptr,ClockTime))) continue;q->startTime=ClockTime;q->endTime=ClockTime+q->cpuTime;q->needTime=q->endTime-q->arivTme;q->prioTime=(double)(q->needTime/q->cpuTime); //此刻要回到原链表把q对应的PCB的Tag标记改为'R' for (qtr=ptr;qtr;qtr=qtr->next){if (qtr->jobName==q->jobName){qtr->Tag='R';}}cout<<" "<<left<<q->jobName<<" "<<left<<q->arivTme<<" "<<left<<q->cpuTime<<" "<<left<<q->startTime<<" "<<left<<q->endTime<<" "<<left<<q->needTime<<" "<<left<<q->prioTime<<endl;ClockTime=q->endTime;m++;}}//主函数void main(){int n,i;PCB job[MAX_JOBNUM];printf("输入进程数目N:");scanf("%d",&n);printf("输入作业信息:......\n进程名到达时间服务时间\n");for(i=0;i<n;i++){cin>>job[i].jobName;cin>>job[i].arivTme;cin>>job[i].cpuTime;}cout<<"\n-------------------------短作业优先 (非抢占)------------------------\n";SJF(job,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++)
if(p[n].arrivetime<=p[m].finishtime) i++; } float min=p[m+1].servicetime; int next=m+1;//m+1=n for(int k=m+1;k<m+i;k++) {
if(p[k+1].servicetime<min)
{ min=p[k+1].servicetime; next=k+1;
printf("请分别输入:\n\t 作业名,到达时间,服务时间(如:JOB1 5 10)\n\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); printf("\n"); } } void Print(jcb *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float avezztime,int N) { int k; printf("调度顺序:"); printf("%s",p[0].name); for(k=1;k<N;k++) { printf("-->%s",p[k].name); } printf("\n\n"); printf("\t\t\t 作业信息:\n"); printf("\nname\tarrive\tservice\tstart\tfinish\tzz\tavezz\n"); for(k=0;k<=N-1;k++) {
优先权调度算法c语言

优先权调度算法c语言以优先权调度算法为题,我们将从人类的视角出发,以自然流畅的语言,介绍该算法的基本概念和实现过程。
首先,让我们进入故事的主人公小明的视角。
小明是一家制造公司的生产主管,他负责管理生产线上的各个任务。
每个任务都有不同的优先级,而小明需要根据这些优先级来安排任务的执行顺序。
他知道,如果任务的优先级得不到合理的调度,会导致生产效率低下,甚至影响公司的运营。
于是,小明开始研究优先权调度算法。
这种算法可以根据任务的优先级来确定任务的执行顺序,以最大化生产效率。
他深入学习了算法的原理和实现方法。
优先权调度算法的核心思想是给每个任务分配一个优先级,然后根据优先级来决定任务的执行顺序。
小明了解到,任务的优先级可以根据多个因素来确定,比如任务的紧急程度、重要性、所需资源等等。
在实际应用中,小明使用了一个优先级队列来存储任务,并根据每个任务的优先级来进行排序。
每当有新的任务到达,他会将其插入到队列中的合适位置。
而当有任务执行完毕时,他会从队列中选取优先级最高的任务进行执行。
小明深知,优先权调度算法的关键在于如何确定任务的优先级。
他根据生产线上的具体情况,制定了一套合理的优先级评估标准。
他考虑了任务的紧急程度、对其他任务的依赖关系以及所需资源等因素,并根据这些因素给每个任务分配了一个合理的优先级。
通过优先权调度算法,小明成功地提高了生产线的效率。
他的团队成员们也感受到了这种变化,每个人都更加明确了自己的任务优先级,工作更加有序高效。
通过这个故事,我们可以看到优先权调度算法对于任务管理的重要性。
它不仅可以提高工作效率,还可以使工作更加有序和高效。
小明通过合理运用这种算法,成功地完成了他的任务,展现了人类智慧的力量。
在现实生活中,我们也可以借鉴这种算法,提高自己的工作效率和生活质量。
- 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);
}。