下载文档原格式
作业调度算法-实验报告作业调度算法模拟一、课题内容和要求常见的作业调度算法有先来先服务算法、最短作业优先算法、响应比优先调度算法。
(1) 参考操作系统教材理解这3种算法。
(2) 实现这3个算法。
(3) 已知若干作业的到达时间和服务时间，用实现的算法计算对该组作业进行调度的平均周转时间Ttime和平均带权周转时间WTtime。
(4) 作业的到达时间和服务时间可以存放在文本文件record.txt中。
(5) 设计简单的交互界面，演示所设计的功能。
(可以使用MFC进行界面的设计) （6）可根据自己能力，在完成以上基本要求后，对程序功能进行适当扩充。
二、需求分析模拟实现作业调度算法，包括：FCFS（先来先服务算法）、SJF（短作业优先算法）、HRN（最高响应比优先算法）、HPF（基于优先数调度算法）。
先来先服务算法：按照各个作业进入系统（输入井）的自然次序来调度算法。
短作业优先算法：优先调度并处理短作业。
所谓的“短作业”并不是指物理作业长度短，而是指作业的运行时间短。
最高响应比优先算法：优先调度并处理响应比最高的作业。
三、概要设计函数中一些类：Time类 int hour 小时 int minute 分钟 Job 类 Int ID 作业编号 Time enter 进入时间 int requesttime 估计运行时间 intpriority 优先数 Time start Time end int Ttime double WTtime 开始时间结束时间周转时间带权周转时间Schedule类 int size Job *job int *r Int Differ() void HRN() 作业数作业数组排序用数组求时间差最高响应比优先 schedule() void readFile() void FCFS() void SJF() 构造函数从文件读信息先来先服务短作业优先主要功能函数的流程图 1、 EDIT1 平均带权周转时间 2、先来先服务：结束 EDIT2 平均周转时间 EDIT4 平均周转时间 EDIT5 平均带权周转时间EDIT6 平均周转时间 EDIT7 平均带权周转时间 OnButton1() FCFS OnButton2() SJF 开始 readFile()给变量赋值 OnButton3() HRN 开始感谢您的阅读，祝您生活愉快。
先来先服务,时间片调度,优先级调度算法实验报告实验报告1. 引言进程调度是操作系统中非常重要的一部分，它决定了进程在CPU上执行的顺序和时间长度。
在本次实验中，我们通过实现先来先服务调度算法、时间片调度算法和优先级调度算法，并对其性能进行比较，来深入了解各种调度算法的工作原理及优缺点。
2. 先来先服务调度算法先来先服务调度算法按照进程到达的先后顺序进行调度。
当一个进程到达时，如果CPU空闲，则将其分配给CPU进行执行；如果CPU 正在执行其他进程，则该进程将等待直到CPU空闲。
优点是简单易实现，适用于长作业。
缺点是可能出现饥饿现象，即低优先级的进程可能会一直等待高优先级进程的执行。
3. 时间片调度算法时间片调度算法将CPU的执行时间划分为固定长度的时间片，每个进程在一个时间片内执行，当时间片用完后，系统将切换到下一个进程执行。
该算法确保每个进程都有公平的执行时间，避免了饥饿现象。
然而，对于CPU利用率较高的情况下，可能会导致进程频繁地切换，增加了上下文切换的开销。
4. 优先级调度算法优先级调度算法根据进程的优先级来进行调度，优先级较高的进程将具有更高的执行优先级。
当多个进程同时到达CPU时，系统将选择优先级最高的进程先执行。
该算法可以分为静态优先级调度和动态优先级调度两种方式。
优点是可以根据进程的重要性灵活调整执行顺序。
缺点是可能导致优先级低的进程长时间等待，造成饥饿现象。
5. 实验结果与分析我们通过模拟多个进程的到达和执行过程，在不同的场景下比较了先来先服务调度算法、时间片调度算法和优先级调度算法的性能。
实验结果显示，在长作业的情况下，先来先服务调度算法表现较好；在要求公平性的场景下，时间片调度算法比较适合；而对于需要根据优先级来调度的场景，优先级调度算法可以更好地满足需求。
6. 结论不同的进程调度算法在不同的场景下有各自的优劣。
先来先服务调度算法简单易实现，适用于长作业；时间片调度算法保证了公平性，适用于要求公平的场景；而优先级调度算法则可以根据进程的重要性进行调度。
实验报告说明
1．实验项目名称：要用最简练的语言反映实验的内容。
要求与实验指导书中相一致。
2．实验类型：一般需说明是验证型实验还是设计型实验，是创新型实验还是综合型实验。
3．实验目的与要求：目的要明确，要抓住重点，符合实验指导书中的要求。
4．实验原理：简要说明本实验项目所涉及的理论知识。
5．实验环境：实验用的软硬件环境（配置）。
6．实验方案设计（思路、步骤和方法等）：这是实验报告极其重要的内容。
概括整个实验过程。
对于操作型实验，要写明依据何种原理、操作方法进行实验，要写明需要经过哪几个步骤来实现其操作。
对于设计型和综合型实验，在上述内容基础上还应该画出流程图、设计思路和设计方法，再配以相应的文字说明。
对于创新型实验，还应注明其创新点、特色。
7．实验过程（实验中涉及的记录、数据、分析）：写明具体上述实验方案的具体实施，包括实验过程中的记录、数据和相应的分析。
8．结论（结果）：即根据实验过程中所见到的现象和测得的数据，做出结论。
9．小结：对本次实验的心得体会、思考和建议。
10．指导教师评语及成绩：指导教师依据学生的实际报告内容，用简练语言给出本次实验报告的评价和价值。
注意：
实验报告将记入实验成绩；
每次实验开始时，交上一次的实验报告，否则将扣除此次实验成绩。
先来先服务调度算法一，实验目的1.加深对先来先服务算法的理解。
2.利用C语言编写算法，模拟实现先来先服务算法。
3.模拟先来先服务算法，并计算平均周转时间和平均带权周转时间。
二，实验开发平台。
Microsoft Visual C++6.0三，调度算法说明先来先服务调度算法，是一种简单的调度算法，该算法即可用于作业调度，也可用于进程调度，就是每次从就绪队列中选择一个最先进入队列的进程，该算法比较有利于长作业，而不利于短作业。
另外，FCFS调度算法对CPU繁忙型作业比较有利，而不利于I/O繁忙作业。
四，实验源程序。
#include "stdio.h"#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0struct jcb {char name[10];char state;/*状态*/int atime; /*到达时刻*/int ntime; /*所需时间*/int ctime; /*完成时刻*/int stime; /*开始时刻*/int ttime; /*周转时间*/float bttime;/*带权周转时间*/struct jcb* link;}*ready=NULL,*p,*q;typedef struct jcb JCB;float wtime=0,wttime=0,wbttime=0;sort(){ if(ready==NULL){p->link=ready;ready=p;q=p;}else{ q->link=p;q=p;}}input(){ int i,num;printf("\n 请输入作业数:");scanf("%d",&num);for(i=0;i<num;i++){printf("\n 作业号No.%d:\n",i);p=getpch(JCB);printf("\n 输入作业名:");scanf("%s",p->name);printf("\n 输入作业所需时间:");scanf("%d",&p->ntime);printf("\n");p->atime=i;p->state='w';p->link=NULL;sort(); /* 调用sort函数*/}}int space(){int l=0; JCB* pr=ready;while(pr!=NULL){l++;pr=pr->link;}return(l);}disp1(JCB* pr) /*建立作业显示函数,用于显示当前作业*/{printf("\n作业名|状态|开始时刻|完成时刻|周转时间|带权周转时间\n"); printf("%s\t",pr->name);printf("%c\t",pr->state);printf("%d\t",pr->stime);printf("%d\t",pr->ctime);printf("%d\t",pr->ttime);printf("%f\t",pr->bttime);printf("\n");}disp2(JCB* pr) /*建立进程显示函数,用于显示当前进程*/{printf("\n作业名|状态|到达时刻|所需时间\n");printf("%s\t",pr->name);printf("%c\t",pr->state);printf("%d\t",pr->atime);printf("%d\t",pr->ntime);printf("\n");}check() /* 建立作业查看函数*/{JCB* pr;pr=ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL){disp2(pr);pr=pr->link;}}destroy() /*建立作业撤消函数(作业运行结束,撤消作业)*/{printf("\n 作业[%s] 已完成.\n",p->name);free(p);}running(){p->stime=wtime;p->ctime=p->stime+p->ntime;p->ttime=p->ctime-p->atime;p->bttime=(float)p->ttime/(float)p->ntime;wtime=wtime+p->ntime;/*printf("时间:%f",wtime);*/wttime=wttime+p->ttime;wbttime=wbttime+p->bttime;printf("\n **** 当前正在运行的作业是:%s",p->name); /*显示当前运行作业*/ disp1(p);destroy();}main() /*主函数*/{int len,h=0;char ch;input();len=space();while((len!=0)&&(ready!=NULL)){ch=getchar();h++;printf("\n The execute number:%d \n",h);p=ready;ready=p->link;p->link=NULL;p->state='R';running();check();printf("\n 按任一键继续......");ch=getchar();}printf("\n\n 作业已经完成.\n");printf("\n该次作业调度平均周转时间:%f\n",wttime/len); printf("\n该次作业调度带权平均周转时间:%f\n",wbttime/len); ch=getchar();}五，实验结果。
调度的调度算法实验报告调度的调度算法实验报告引言：调度是计算机科学中一个重要的概念，它涉及到任务分配、资源管理和优化等方面。
调度算法则是实现调度的关键，它决定了任务的执行顺序和资源的分配方式。
在本次实验中，我们将探讨几种常见的调度算法，并通过实验对其性能进行评估和比较。
一、先来先服务算法（FCFS）先来先服务算法是最简单的调度算法之一，它按照任务到达的先后顺序进行处理。
实验中，我们模拟了一个任务队列，每个任务有不同的执行时间。
通过实验结果可以看出，FCFS算法的优点是简单易懂，但当任务的执行时间差异较大时，会导致平均等待时间较长。
二、最短作业优先算法（SJF）最短作业优先算法是一种非抢占式调度算法，它根据任务的执行时间来进行排序。
实验中，我们将任务按照执行时间从短到长进行排序，并进行调度。
实验结果显示，SJF算法的优点是能够最大程度地减少平均等待时间，但当任务的执行时间无法预测时，该算法可能会导致长任务等待时间过长的问题。
三、时间片轮转算法（RR）时间片轮转算法是一种抢占式调度算法，它将任务分为多个时间片，并按照顺序进行调度。
实验中，我们设置了每个时间片的长度，并将任务按照到达顺序进行调度。
实验结果表明，RR算法的优点是能够公平地分配资源，但当任务的执行时间超过一个时间片时，会导致上下文切换频繁，影响系统的性能。
四、最高响应比优先算法（HRRN）最高响应比优先算法是一种动态调度算法，它根据任务的等待时间和执行时间来计算响应比，并选择响应比最高的任务进行调度。
实验中，我们根据任务的到达时间、执行时间和等待时间计算响应比，并进行调度。
实验结果显示，HRRN算法能够在一定程度上平衡长任务和短任务的等待时间，但当任务的执行时间过长时，会导致其他任务的等待时间过长。
五、多级反馈队列算法（MFQ）多级反馈队列算法是一种综合性的调度算法，它将任务分为多个队列，并根据任务的执行情况进行调度。
实验中，我们设置了多个队列，并根据任务的执行时间和等待时间进行调度。
先来先服务调度和最短作业优先调度算法实验报告实验报告一、实验目的本实验旨在通过编写代码实现先来先服务调度算法和最短作业优先调度算法，以深入理解和掌握这两种调度算法的原理和实现方法。
二、实验方法和原理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:```运行以上代码，会得到相应的作业调度结果。
先来先服务FCFS和短作业优先SJF进程调度算法1、实验目的通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。
2、需求分析(1) 输入的形式和输入值的范围输入值：进程个数Num 范围：0<Num<=100依次输入Num个进程的到达时刻范围：依次输入Num个进程的服务时刻范围：输入要使用的算法（1-FCFS，2-SJF）范围：1或者2(2) 输出的形式（X表示变量）时刻X：进程X开始运行。
其完成时刻：X 周转时刻：X 带权周转时刻：X…（省略（Num-1）个）平均周转时刻：X平均带权周转时刻：X(3) 程序所能达到的功能输入进程个数Num，每个进程到达时刻ArrivalTime[i]，服务时刻ServiceTime[i]。
采纳先来先服务FCFS或者短作业优先SJF进程调度算法进行调度，计算每个进程的完成时刻、周转时刻和带权周转时刻，同时统计Num个进程的平均周转时刻和平均带权周转时刻。
3、概要设计讲明本程序中用到的所有抽象数据类型的定义、主程序的流程以及各程序模块之间的层次(调用)关系。
4、详细设计5、调试分析(1)调试过程中遇到的问题以及解决方法，设计与实现的回忆讨论和分析○1开始的时候没有推断进程是否到达，导致短进程优先算法运行结果错误，后来加上了推断语句后就解决了改问题。
○2差不多完成的设计所要实现的功能，总的来讲，FCFS编写容易，SJF需要先找到差不多到达的进程，再从差不多到达的进程里找到进程服务时刻最短的进程，再进行计算。
(2)算法的改进设想改进：即使用户输入的进程到达时刻没有先后顺序也能准确的计算出结果。
（确实是再加个循环，推断各个进程的到达时刻先后，组成一个有序的序列）(3)经验和体会通过本次实验，深入理解了先来先服务和短进程优先进程调度算法的思想，培养了自己的动手能力，通过实践加深了经历。
6、用户使用讲明（1）输入进程个数Num（2）依次输入Num个进程的到达时刻（3）依次输入Num个进程的服务时刻（4）选择要使用的算法7、测试结果正确一（FCFS）：正确一（SJF）：正确二（FCFS）：正确二（SJF）：错误（进程个数错误）：错误（选择算法错误）：8、附录//***************************************************** **************//** 进程调度算法 BY：09软件工程二班李群**//***************************************************** **************#include<iostream>#include<iomanip>using namespace std;static const int Max=100;int ArrivalTime[Max];//到达时刻int ServiceTime[Max];//服务时刻int FinishTime[Max];//完成时刻int WholeTime[Max];//周转时刻double WeightWholeTime[Max];//帯权周庄时刻double AverageWT_FCFS,AverageWT_SJF; //平均周转时刻double AverageWWT_FCFS,AverageWWT_SJF;//平均帯权周转时刻int ServiceTime_SJF[Max];//在SJF算法中使用到int Num=0;int NowTime=0;//记录当前时刻double SumWT=0,SumWWT=0;//SumWT用来计算总的周转时刻，SumWWT用来计算总的帯权周转时刻int i;int choice;//记录选择//***************************************************** *************// 先到先服务算法//***************************************************** *************void FCFS()//找最早到达的。
作业调度实验报告一、实验目的本次作业调度实验的主要目的是深入理解和掌握作业调度的基本原理和算法，通过实际编程和模拟实验，分析不同调度策略对系统性能的影响，从而为优化作业调度提供理论依据和实践经验。
二、实验环境本次实验在 Windows 10 操作系统下进行，使用 Python 语言作为主要的编程工具。
实验中所需的相关库包括｀numpy`、｀matplotlib` 等。
三、实验原理作业调度是操作系统中的一个重要组成部分，其主要任务是根据一定的调度策略，从就绪队列中选择作业并分配处理机资源，以实现系统资源的高效利用和作业的快速执行。
常见的作业调度算法包括先来先服务（FCFS）、短作业优先（SJF）、优先级调度、高响应比优先调度等。
先来先服务算法按照作业到达的先后顺序进行调度，先到达的作业先执行。
这种算法简单直观，但可能导致长作业长时间等待，影响系统的平均周转时间。
短作业优先算法优先调度执行时间短的作业，能够有效地减少作业的平均等待时间，但可能会导致长作业饥饿。
优先级调度根据作业的优先级来决定执行顺序，优先级高的作业先执行。
然而，确定合理的优先级是一个复杂的问题。
高响应比优先调度综合考虑了作业的等待时间和执行时间，通过计算响应比来决定作业的执行顺序，在一定程度上避免了长作业饥饿的问题。
四、实验内容（一）算法实现1、先来先服务算法｀｀｀pythondef fcfs_scheduling(jobs)：start_time ＝ 0 len(jobs)finish_time ＝ 0 len(jobs)waiting_time ＝ 0 len(jobs)turnaround_time ＝ 0 len(jobs)current_time ＝ 0for i in range(len(jobs)）：start_timei ＝ current_timefinish_timei ＝ current_time ＋ jobsiturnaround_timei ＝ finish_timei 0current_time ＝ finish_timeireturn waiting_time, turnaround_time｀｀｀2、短作业优先算法｀｀｀pythondef sjf_scheduling(jobs)：sorted_jobs ＝ sorted(jobsitems(）， key=lambda x: x1) start_time ＝ 0 len(sorted_jobs)finish_time ＝ 0 len(sorted_jobs)waiting_time ＝ 0 len(sorted_jobs)turnaround_time ＝ 0 len(sorted_jobs)current_time ＝ 0for i in range(len(sorted_jobs)）：start_timei ＝ current_timefinish_timei ＝ current_time ＋ sorted_jobsi1turnaround_timei ＝ finish_timei 0current_time ＝ finish_timeireturn waiting_time, turnaround_time｀｀｀3、优先级调度算法｀｀｀pythondef priority_scheduling(jobs)：sorted_jobs ＝ sorted(jobsitems(）， key=lambda x: x2, reverse=True) start_time ＝ 0 len(sorted_jobs)finish_time ＝ 0 len(sorted_jobs)waiting_time ＝ 0 len(sorted_jobs)turnaround_time ＝ 0 len(sorted_jobs)current_time ＝ 0for i in range(len(sorted_jobs)）：start_timei ＝ current_timefinish_timei ＝ current_time ＋ sorted_jobsi1turnaround_timei ＝ finish_timei 0current_time ＝ finish_timeireturn waiting_time, turnaround_time｀｀｀4、高响应比优先调度算法｀｀｀pythondef hrrn_scheduling(jobs)：response_ratio ＝for i in range(len(jobs)）：waiting_time ＝ 0for j in range(i)：waiting_time ＋＝ jobsjresponse_ratioappend(（waiting_time ＋ jobsi) ／ jobsi)sorted_jobs ＝ job for ＿, job in sorted(zip(response_ratio, jobs)，reverse=True)start_time ＝ 0 len(sorted_jobs)finish_time ＝ 0 len(sorted_jobs)waiting_time ＝ 0 len(sorted_jobs)turnaround_time ＝ 0 len(sorted_jobs)current_time ＝ 0for i in range(len(sorted_jobs)）：start_timei ＝ current_timefinish_timei ＝ current_time ＋ sorted_jobsiwaiting_timei ＝ current_timeturnaround_timei ＝ finish_timei 0current_time ＝ finish_timeireturn waiting_time, turnaround_time｀｀｀（二）实验数据生成为了模拟不同的作业情况，生成了三组具有不同特点的作业数据，分别是：1、作业执行时间均匀分布的数据。
作业调度实验报告作业调度实验报告引言：作业调度是计算机操作系统中的一个重要概念，它涉及到如何合理地安排和管理计算机系统中的各个作业的执行顺序，以提高计算机系统的效率和资源利用率。
本实验旨在通过模拟不同的作业调度算法，探究它们在不同场景下的性能表现。
实验目的：1. 了解作业调度的基本概念和原理；2. 掌握作业调度算法的实现方法；3. 分析不同作业调度算法在不同场景下的优缺点。
实验过程：1. 实验环境的搭建在实验开始前，我们需要搭建一个适合进行作业调度实验的环境。
我们选择了一台配置较高的计算机，并安装了操作系统和相关的开发工具。
2. 实验数据的准备为了模拟真实的作业调度场景，我们需要准备一些作业数据。
这些数据包括作业的到达时间、执行时间、优先级等信息。
我们通过编写程序生成了一批随机的作业数据，并将其保存在文件中。
3. 实验算法的实现根据实验要求，我们实现了三种常见的作业调度算法：先来先服务（FCFS）、最短作业优先（SJF）和优先级调度算法（Priority Scheduling）。
我们使用C语言编写了相应的代码，并对其进行了测试和调试。
4. 实验结果的分析我们将不同作业调度算法在相同作业数据下的运行结果进行了比较和分析。
通过观察和统计，我们得到了各个算法的平均周转时间、平均等待时间等性能指标。
同时，我们还通过绘制图表的方式直观地展示了这些数据。
实验结果与讨论：1. 先来先服务算法（FCFS）先来先服务算法是最简单的作业调度算法之一，它按照作业到达的顺序依次执行。
在实验中，我们发现该算法对于短作业来说表现较好，但对于长作业来说会导致平均等待时间较长。
2. 最短作业优先算法（SJF）最短作业优先算法是一种非抢占式的调度算法，它优先执行执行时间最短的作业。
在实验中，我们发现该算法能够有效减少平均等待时间，但对于长作业来说可能会导致饥饿现象。
3. 优先级调度算法（Priority Scheduling）优先级调度算法根据作业的优先级来安排执行顺序。
操作系统实验_先来先服务的调度算法及短作业优先先来先服务调度算法是一种非抢占式的调度算法，它按照作业到达的先后顺序将作业分配给CPU。
具体来说，当一个作业进入就绪队列时，调度程序将把它放在队列的末尾，然后从队列的头部选择一个作业执行。
只有当一个作业执行完成后，作业队列的头部才会选择下一个作业执行。
先来先服务调度算法的优点是简单易实现，没有复杂的排序操作，适用于短作业和长作业混合的场景。
其缺点是没有考虑作业的执行时间，导致长作业会占用CPU很长时间，影响其他作业的响应时间。
短作业优先调度算法是一种抢占式的调度算法，它根据作业的执行时间选择优先级。
具体来说，当一个作业进入就绪队列时，调度程序会比较该作业的执行时间和其他就绪作业的执行时间，并选择执行时间最短的作业执行。
如果有一个新的作业到达，且其执行时间比当前执行的作业要短，那么调度程序会中断当前作业的执行并切换到新的作业执行。
短作业优先调度算法的优点是能够最大程度上减少作业的等待时间和响应时间，提高系统的吞吐量。
其缺点是需要对作业的执行时间有较准确的估计，否则可能导致长作业陷入饥饿状态。
此外，由于需要频繁进行作业的切换，短作业优先调度算法在实现上相对复杂。
在实际应用中，先来先服务调度算法适用于短作业和长作业混合的场景，或者作业的执行时间无法估计准确的情况下。
例如，在批处理系统中，作业的执行时间往往是固定的，先来先服务调度算法可以保证公平性，并且能够有效利用CPU资源。
而短作业优先调度算法适用于多任务环境下，作业的执行时间可以估计准确的情况下。
例如，在交互式系统中，用户的操作往往是短暂的，短作业优先调度算法可以最大限度地减少用户的等待时间，提高系统的响应速度。
总之，先来先服务调度算法和短作业优先调度算法是操作系统中常用的两种调度算法。
它们分别适用于不同的应用场景，在实际应用中可以根据具体需求选择不同的调度算法。
实验二作业调度实验一. 目的要求：用高级语言编写和调试一个或多个作业调度的模拟程序，以加深对作业调度算法的理解。
二. 例题：为单道批处理系统设计一个作业调度程序。
由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的 CPU时限等因素。
作业调度算法：采用先来先服务（FCFS）调度算法，即按作业提交的先后次序进行调度。
总是首先调度在系统中等待时间最长的作业。
每个作业由一个作业控制块JCB表示，JCB可以包含如下信息：作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。
作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。
每个作业的最初状态总是等待W。
各个等待的作业按照提交时刻的先后次序排队，总是首先调度等待队列中队首的作业。
每个作业完成后要打印该作业的开始运行时刻、完成时刻、周转时间和带权周转时间，这一组作业完成后要计算并打印这组作业的平均周转时间、带权平均周转时间。
调度算法的流程图如下图所示。
三 . 实习题：1、编写并调试一个单道处理系统的作业等待模拟程序。
作业等待算法：分别采用先来先服务（FCFS），最短作业优先（SJF）、响应比高者优先（HRN）的调度算法。
对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间，以比较各种算法的优缺点。
实验代码：#include <stdio.h>#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type)) #define NULL 0int n;float T1=0,T2=0;int times=0;struct jcb //作业控制块{char name[10]; //作业名int reachtime; //作业到达时间int starttime; //作业开始时间int needtime; //作业需要运行的时间float super; //作业的响应比int finishtime; //作业完成时间float cycletime; //作业周转时间float cltime; //作业带权周转时间char state; //作业状态struct jcb *next; //结构体指针}*ready=NULL,*p,*q;typedef struct jcb JCB;void inize() //初始化界面{printf("\n\n\t\t****************************************** ***\t\t\n");printf("\t\t\t\t单道批处理作业调度系统\n");printf("\t\t*********************************************\ t\t\n");printf("\n\n\n\t\t\t\t软件143赵媛媛\n\n");printf("\t\t\t\t\t\n");printf("\n\n\n\t\t请输入任意键进入……\n");getch();}void inital() //建立作业控制块队列,先将其排成先来先服务的模式队列{int i;printf("\n输入作业数:");scanf("%d",&n);for(i=0;i<n;i++){p=getpch(JCB);printf("\n输入作业名:");scanf("%s",p->name);getch();p->reachtime=i;printf("作业默认到达时间:%d",i);printf("\n输入作业要运行的时间:");scanf("%d",&p->needtime);p->state='W';p->next=NULL;if(ready==NULL) ready=q=p;else{q->next=p;q=p;}}}void disp(JCB* q,int m) //显示作业运行后的周转时间及带权周转时间等{if(m==3) //显示高响应比算法调度作业后的运行情况{printf("\n作业%s正在运行，估计其运行情况：\n",q->name);printf("开始运行时刻：%d\n",q->starttime);printf("完成时刻：%d\n",q->finishtime);printf("周转时间：%f\n",q->cycletime);printf("带权周转时间：%f\n",q->cltime);printf("相应比:%f\n",q->super);getch();}else // 显示先来先服务,最短作业优先算法调度后作业的运行情况{printf("\n作业%s正在运行，估计其运行情况：\n",q->name);printf("开始运行时刻：%d\n",q->starttime);printf("完成时刻：%d\n",q->finishtime);printf("周转时间：%f\n",q->cycletime);printf("带权周转时间：%f\n",q->cltime);getch();}}void running(JCB *p,int m) //运行作业{if(p==ready) //先将要运行的作业从队列中分离出来{ready=p->next;p->next=NULL;}else{q=ready;while(q->next!=p) q=q->next;q->next=p->next;}p->starttime=times; //计算作业运行后的完成时间,周转时间等等p->state='R';p->finishtime=p->starttime+p->needtime;p->cycletime=(float)(p->finishtime-p->reachtime);p->cltime=(float)(p->cycletime/p->needtime);T1+=p->cycletime;T2+=p->cltime;disp(p,m); //调用disp()函数,显示作业运行情况times+=p->needtime;p->state='F';printf("\n%s has been finished!\npress any key to continue...\n",p->name);free(p); //释放运行后的作业getch();}void super() //计算队列中作业的高响应比JCB *padv;padv=ready;do{if(padv->state=='W'&&padv->reachtime<=times)padv->super=(float)(times-padv->reachtime+padv->needtime)/ padv->needtime;padv=padv->next;}while(padv!=NULL);}void final() //最后打印作业的平均周转时间,平均带权周转时间{float s,t;t=T1/n;s=T2/n;getch();printf("\n\n作业已经全部完成!");printf("\n%d个作业的平均周转时间是：%f",n,t);printf("\n%d个作业的平均带权周转时间是%f：\n\n\n",n,s);}void hrn(int m) //高响应比算法JCB *min;int i,iden;system("cls");inital();for(i=0;i<n;i++){p=min=ready;iden=1;super();do{if(p->state=='W'&&p->reachtime<=times)if(iden){min=p;iden=0;}else if(p->super>min->super) min=p; p=p->next;}while(p!=NULL);if(iden){i--;times++;//printf("\ntime=%d:\tno JCB submib...wait...",time); if(times>1000){printf("\nruntime is too long...error...");getch();} }else{running(min,m); //调用running()函数 }} //forfinal(); //调用running()函数}void sjf(int m) // 最短作业优先算法{JCB *min;int i,iden;system("cls");inital();for(i=0;i<n;i++){p=min=ready;iden=1;do{if(p->state=='W'&&p->reachtime<=times)if(iden){min=p;iden=0;}else if(p->needtime<min->needtime) min=p;p=p->next;}while(p!=NULL) ;if(iden) {i--; //printf("\ntime=%d:\tno JCB submib...wait...",time);times++;if(times>100){printf("\nruntime is too long...error");getch();}}else{running(min,m); //调用running()函数 }} //forfinal(); //调用running()函数}void fcfs(int m) //先来先服务算法{int i,iden;system("cls");inital();for(i=0;i<n;i++){p=ready;iden=1;do{if(p->state=='W'&&p->reachtime<=times) iden=0;if(iden)p=p->next;}while(p!=NULL&&iden) ;if(iden){i--;printf("\n没有满足要求的进程,需等待");times++;if(times>100){printf("\n时间过长");getch();}}else{running(p,m); //调用running()函数}}final(); //调用running()函数}void mune(){int m;system("cls");printf("\n\n\t\t****************************************** ***\t\t\n");printf("\t\t\t\t作业调度演示\n");printf("\t\t*********************************************\ t\t\n");printf("\n\n\n\t\t\t1.先来先服务算法.");printf("\n\t\t\t2.最短作业优先算法.");printf("\n\t\t\t3.响应比高者优先算法"); printf("\n\t\t\t0.退出程序.");printf("\n\n\t\t\t\t选择所要操作:");scanf("%d",&m);switch(m){ case 1:fcfs(m);getch();system("cls");mune();break;case 2:sjf(m);getch();system("cls");mune();break;case 3:hrn(m);getch();system("cls");mune();break;case 0:system("cls");break;default:printf("选择错误,重新选择.");getch();system("cls");mune();}}main() //主函数{inize();mune();}实验截图2、编写并调度一个多道程序系统的作业调度模拟程序。
