操作系统作业调度实验
操作系统作业调度算法实验
操作系统作业调度算法实验
操作系统作业调度算法实验可以让你更深入地理解作业调度的概念和方法，以下是实验的基本步骤和内容：
一、实验目的
掌握作业调度的基本概念和算法原理。
理解不同作业调度算法的特点和优缺点。
通过实验验证作业调度算法的正确性和性能。
二、实验内容
实验准备：准备一台计算机或模拟器，安装操作系统，并准备好实验所需的作业。
实验步骤：
（1）编写作业描述文件，包括作业的名称、到达时间、所需资源等信息。
（2）实现先来先服务（FCFS）、最短作业优先（SJF）、最高响应比优先（HRN）等作业调度算法，并编写相应的调度程序。
（3）将作业按照一定的顺序输入到调度程序中，并记录每个作业的执行时间、等待时间等参数。
（4）根据记录的数据计算平均周转时间、平均带权周转时间等指标，分析不同调度算法的性能差异。
（5）根据实验结果，分析不同调度算法的优缺点，并给出改进建议。
实验报告：整理实验数据和结果，撰写实验报告，包括实验目的、实验内容、实验步骤、实验结果、分析和结论等部分。
三、实验注意事项
在实验过程中，要注意保证作业的公平性，避免某些作业一直得不到执行的情况发生。
在实验过程中，要注意观察和记录每个作业的执行时间和等待时间等参数，以便后续的分析和比较。
在实验过程中，要注意保证系统的稳定性和可靠性，避免出现意外情况导致实验结果不准确。
在实验过程中，要注意遵守实验室规定和操作规程，确保实验过程的安全和顺利进行。
操作系统进程调度算法模拟实验报告
操作系统进程调度算法模拟实验报告一、实验目的本实验旨在深入理解操作系统的进程调度算法，并通过模拟实验来探究不同调度算法之间的差异和优劣。
二、实验原理操作系统的进程调度算法是决定进程执行顺序的重要依据。
常见的调度算法有先来先服务（FCFS）、最短作业优先（SJF）、优先级调度（Priority Scheduling）、轮转法（Round Robin）和多级反馈队列调度（Multilevel Feedback Queue Scheduling）等。
1.先来先服务（FCFS）算法：按照进程到达的先后顺序进行调度，被调度的进程一直执行直到结束或主动阻塞。
2.最短作业优先（SJF）算法：按照进程需要的执行时间的短长程度进行调度，执行时间越短的进程越优先被调度。
3. 优先级调度（Priority Scheduling）算法：为每个进程分配一个优先级，按照优先级从高到低进行调度。
4. 轮转法（Round Robin）算法：将进程按照到达顺序排列成一个队列，每个进程被分配一个时间片（时间量度），当时间片结束时，将进程从队列头取出放置到队列尾。
5.多级反馈队列调度算法：将进程队列分为多个优先级队列，每个队列时间片大小依次递减。
当一个队列中的进程全部执行完毕或者发生阻塞时，将其转移到下一个优先级队列。
三、实验步骤与结果1.实验环境：- 操作系统：Windows 10- 编译器：gcc2.实验过程：（1）首先，设计一组测试数据，包括进程到达时间、需要的执行时间和优先级等参数。
（2）根据不同的调度算法编写相应的调度函数，实现对测试数据的调度操作。
（3）通过模拟实验，观察不同调度算法之间的区别，比较平均等待时间、完成时间和响应时间的差异。
（4）将实验过程和结果进行记录整理，撰写实验报告。
3.实验结果：这里列举了一组测试数据和不同调度算法的结果，以便对比分析：进程，到达时间，执行时间，优先------，----------，----------，-------P1，0，10，P2，1，1，P3，2，2，P4，3，1，P5，4，5，a.先来先服务（FCFS）算法：平均等待时间：3.8完成时间：15b.最短作业优先（SJF）算法：平均等待时间：1.6完成时间：11c. 优先级调度（Priority Scheduling）算法：平均等待时间：2.8完成时间：14d. 轮转法（Round Robin）算法：时间片大小：2平均等待时间：4.8完成时间：17e.多级反馈队列调度算法：第一级队列时间片大小：2第二级队列时间片大小：4平均等待时间：3.8完成时间：17四、实验总结通过上述的实验结果可以得出以下结论：1.在上述测试数据中，最短作业优先（SJF）算法的平均等待时间最短，说明该算法在短作业的情况下能够有效地减少等待时间。
操作系统——作业调度
操作系统——作业调度实验⼆作业调度模拟程序⼀、⽬的和要求 1. 实验⽬的 （1）加深对作业调度算法的理解； （2）进⾏程序设计的训练。
2．实验要求 ⽤⾼级语⾔编写⼀个或多个作业调度的模拟程序。
单道批处理系统的作业调度程序。
作业⼀投⼊运⾏，它就占有计算机的⼀切资源直到作业完成为⽌，因此调度作业时不必考虑它所需要的资源是否得到满⾜，它所运⾏的时间等因素。
作业调度算法： 1) 采⽤先来先服务（FCFS）调度算法，即按作业到达的先后次序进⾏调度。
总是⾸先调度在系统中等待时间最长的作业。
2) 短作业优先 (SJF) 调度算法，优先调度要求运⾏时间最短的作业。
3) 响应⽐⾼者优先(HRRN)调度算法，为每个作业设置⼀个优先权(响应⽐)，调度之前先计算各作业的优先权，优先数⾼者优先调度。
RP (响应⽐)＝作业周转时间 / 作业运⾏时间=1+作业等待时间/作业运⾏时间每个作业由⼀个作业控制块JCB表⽰，JCB可以包含以下信息：作业名、提交（到达）时间、所需的运⾏时间、所需的资源、作业状态、链指针等等。
作业的状态可以是等待W（Wait）、运⾏R（Run）和完成F（Finish）三种之⼀。
每个作业的最初状态都是等待W。
⼀、模拟数据的⽣成 1．允许⽤户指定作业的个数（2-24），默认值为5。
2. 允许⽤户选择输⼊每个作业的到达时间和所需运⾏时间。
3.（**）从⽂件中读⼊以上数据。
4.（**）也允许⽤户选择通过伪随机数指定每个作业的到达时间（0-30）和所需运⾏时间（1-8）。
⼆、模拟程序的功能 1．按照模拟数据的到达时间和所需运⾏时间，执⾏FCFS, SJF和HRRN调度算法，程序计算各作业的开始执⾏时间，各作业的完成时间，周转时间和带权周转时间（周转系数）。
2. 动态演⽰每调度⼀次，更新现在系统时刻，处于运⾏状态和等待各作业的相应信息（作业名、到达时间、所需的运⾏时间等）对于HRRN算法，能在每次调度时显⽰各作业的响应⽐R情况。
操作系统进程调度实验
操作系统进程调度实验操作系统进程调度是操作系统中非常重要的一个功能，它决定了多个进程的执行顺序和调度策略。
进程调度的好坏直接影响着系统的性能和资源利用率。
本实验旨在通过实现一个简单的进程调度模拟，了解不同的调度算法，探讨其优劣和适用场景。
一、实验目的和原理本实验的目标是实现进程调度模拟，并探究不同调度算法的性能和适用场景。
通过实验，我们可以了解以下内容：1.进程调度算法的基本原理和实现方式；2.比较不同调度算法的优劣和特点；3.了解不同调度算法在不同场景下的应用。
二、实验环境和工具本实验使用C语言进行实现，可以选择任何一种编程环境和工具，例如Dev-C++、Visual Studio等。
三、实验过程及方法1.实现一个进程控制块（PCB）的数据结构，用来保存进程的相关信息，包括进程ID、进程状态、优先级等。
2.实现一个进程队列，用来保存就绪队列中的进程。
可以使用数组或链表等数据结构实现。
3. 实现不同调度算法的函数，包括先来先服务（FCFS）、最短作业优先（SJF）、优先级调度（Priority Scheduling）和时间片轮转（Round Robin）等。
4.根据实际需求生成一批进程，设置其信息，并根据不同算法进行调度。
5.对比不同算法的运行结果和性能，分析其优劣。
四、实验结果和分析通过实验，我们可以得到每个算法的平均等待时间、平均周转时间和吞吐量等性能指标。
根据这些指标，我们可以对不同算法进行评价和分析。
1.先来先服务（FCFS）算法FCFS算法是最简单的调度算法，按照进程到达的顺序进行调度。
它的主要优点是实现简单、公平性好。
然而，FCFS算法有明显的缺点，会导致长作业等待时间过长，产生"饥饿"现象。
2.最短作业优先（SJF）算法SJF算法是按照进程的执行时间长短进行调度的算法。
它能够最大限度地减少平均等待时间和周转时间，但是需要提前知道所有进程的执行时间，这在实际中是很难做到的。
操作系统实验_先来先服务的调度算法及短作业优先
操作系统实验_先来先服务的调度算法及短作业优先1.引言操作系统的调度算法是指在多进程环境中，操作系统为进程分配CPU 的顺序和策略。
先来先服务（FCFS）调度算法是最简单的调度算法之一，它按照进程到达的顺序为其分配CPU。
而短作业优先（SJF）调度算法是根据进程的执行时间来为其分配CPU，执行时间越短的进程越先执行。
本文将分别介绍FCFS调度算法和SJF调度算法，并对其进行评价和比较。
2.先来先服务（FCFS）调度算法2.1调度原理FCFS调度算法的原理非常简单，按照进程到达的顺序为其分配CPU。
当一个进程进入就绪队列后，如果CPU空闲，则立即为其分配CPU。
如果CPU正忙，则进程进入等待队列，等待CPU空闲后再分配。
在该算法中，进程的运行时间不考虑，只考虑进程到达的时间。
2.2优点与缺点FCFS调度算法的主要优点是实现简单，无需对进程的运行时间进行估计。
但FCFS算法存在一定的缺点。
首先，长作业在短作业前面等待的时间较长，可能导致长作业的响应时间过长。
其次，如果有一个进程出现阻塞或响应时间过长，其后面的进程也会受到影响，造成整个系统的性能下降。
3.短作业优先（SJF）调度算法3.1调度原理短作业优先（SJF）调度算法是根据进程的执行时间来为其分配CPU。
当一个进程进入就绪队列后，如果其执行时间比当前正在运行的进程短，则优先为该进程分配CPU。
如果当前没有运行的进程或者当前运行的进程执行完毕，则立即为该进程分配CPU。
在该算法中，进程的到达时间不考虑，只考虑进程的执行时间。
3.2优点与缺点SJF调度算法的主要优点是可以最大程度地减少平均等待时间，提高系统的吞吐量。
短作业可以快速执行完毕，从而让更多的作业得以执行。
但SJF算法存在一定的缺点。
首先，需要对进程的执行时间有一个准确的估计，对于实时系统或动态系统来说，估计执行时间可能会有一定的误差。
其次，在长作业激增的情况下，短作业可能会一直得不到CPU的分配，造成长时间的等待。
操作系统最高响应比优先调度算法实验报告
操作系统最高响应比优先调度算法实验报告一、实验目的1.了解操作系统中调度算法的概念和特点；2.掌握最高响应比优先调度算法的原理和实现；3.通过实验验证最高响应比优先调度算法在不同场景下的性能表现。
二、实验原理最高响应比优先调度算法是一种比较常见的作业调度算法，主要用于提高作业的响应速度和用户体验。
该算法的原则是根据作业的响应比来决定作业的调度顺序，响应比越高，优先级越高。
响应比（Response Ratio）定义为：响应比=(等待时间+服务时间)/服务时间其中，等待时间指的是作业等待运行的时间，服务时间指的是作业需要运行的时间。
在最高响应比优先调度算法中，每次从就绪队列中选择响应比最高的作业进行调度，直到所有作业都完成。
三、实验过程1.设计实验场景，包括作业数、服务时间和到达时间等参数；2.实现最高响应比优先调度算法的调度程序；3.根据参数设置，将作业按照到达时间的先后顺序放入就绪队列；4.按照最高响应比优先调度算法的原则，选择响应比最高的作业进行调度；5.更新作业的等待时间和响应比，并记录作业的调度顺序；6.统计作业的平均等待时间和平均响应时间，并输出结果。
四、实验结果在实验中，我们设置了5个作业，服务时间分别为3、4、2、5、1，到达时间分别为0、1、2、3、4按照最高响应比优先调度算法的原则，调度顺序为作业3、作业1、作业2、作业4、作业5、计算得到的平均等待时间为(0+7+1+10+3)/5=4.2，平均响应时间为(3+7+3+14+1)/5=5.6五、实验总结通过本次实验，我们了解了最高响应比优先调度算法的原理和实现过程。
该调度算法能够有效提高作业的响应速度和用户体验，但在实际应用中也存在一些问题，比如容易出现饥饿现象，即一些低响应比的作业可能一直得不到调度。
在选择调度算法时，需要根据实际情况和需求来进行权衡和选择，最高响应比优先调度算法适用于对响应时间要求较高的场景，但在其他场景下可能不适用。
操作系统实验_先来先服务的调度算法及短作业优先
操作系统实验_先来先服务的调度算法及短作业优先先来先服务调度算法是一种非抢占式的调度算法，它按照作业到达的先后顺序将作业分配给CPU。
具体来说，当一个作业进入就绪队列时，调度程序将把它放在队列的末尾，然后从队列的头部选择一个作业执行。
只有当一个作业执行完成后，作业队列的头部才会选择下一个作业执行。
先来先服务调度算法的优点是简单易实现，没有复杂的排序操作，适用于短作业和长作业混合的场景。
其缺点是没有考虑作业的执行时间，导致长作业会占用CPU很长时间，影响其他作业的响应时间。
短作业优先调度算法是一种抢占式的调度算法，它根据作业的执行时间选择优先级。
具体来说，当一个作业进入就绪队列时，调度程序会比较该作业的执行时间和其他就绪作业的执行时间，并选择执行时间最短的作业执行。
如果有一个新的作业到达，且其执行时间比当前执行的作业要短，那么调度程序会中断当前作业的执行并切换到新的作业执行。
短作业优先调度算法的优点是能够最大程度上减少作业的等待时间和响应时间，提高系统的吞吐量。
其缺点是需要对作业的执行时间有较准确的估计，否则可能导致长作业陷入饥饿状态。
此外，由于需要频繁进行作业的切换，短作业优先调度算法在实现上相对复杂。
在实际应用中，先来先服务调度算法适用于短作业和长作业混合的场景，或者作业的执行时间无法估计准确的情况下。
例如，在批处理系统中，作业的执行时间往往是固定的，先来先服务调度算法可以保证公平性，并且能够有效利用CPU资源。
而短作业优先调度算法适用于多任务环境下，作业的执行时间可以估计准确的情况下。
例如，在交互式系统中，用户的操作往往是短暂的，短作业优先调度算法可以最大限度地减少用户的等待时间，提高系统的响应速度。
总之，先来先服务调度算法和短作业优先调度算法是操作系统中常用的两种调度算法。
它们分别适用于不同的应用场景，在实际应用中可以根据具体需求选择不同的调度算法。
作业调度算法(先来先服务算法,短作业算法)
《操作系统》实验报告题目：作业调度算法班级：网络工程姓名：朱锦涛学号：E31314037一、实验目的用代码实现页面调度算法，即先来先服务（FCFS）调度算法、短作业优先算法、高响应比优先调度算法。
通过代码的具体实现，加深对算法的核心的理解。
二、实验原理1.先来先服务（FCFS）调度算法FCFS是最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。
当在作业调度中采用该算法时，系统将按照作业到达的先后次序来进行调度，或者说它是优先考虑在系统中等待时间最长的作业，而不管该作业所需执行的时间的长短，从后备作业队列中选择几个最先进入该队列的作业，将它们调入内存，为它们分配资源和创建进程。
然后把它放入就绪队列。
2.短作业优先算法SJF算法是以作业的长短来计算优先级，作业越短，其优先级越高。
作业的长短是以作业所要求的运行时间来衡量的。
SJF算法可以分别用于作业和进程调度。
在把短作业优先调度算法用于作业调度时，它将从外存的作业后备队列中选择若干个估计运行时间最短的作业，优先将它们调入内存。
3、高响应比优先调度算法高响应比优先调度算法则是既考虑了作业的等待时间，又考虑了作业的运行时间的算法，因此既照顾了短作业，又不致使长作业等待的时间过长，从而改善了处理机调度的性能。
如果我们引入一个动态优先级，即优先级是可以改变的令它随等待的时间的延长而增加，这将使长作业的优先级在等待期间不断地增加，等到足够的时间后，必然有机会获得处理机。
该优先级的变化规律可以描述为：优先权 = （等待时间 + 要求服务时间）/要求服务时间三、实验内容源程序：#include<stdio.h>#include<stdlib.h>#include<time.h>struct work{i nt id;i nt arrive_time;i nt work_time;i nt wait;f loat priority;};typedef struct sjf_work{s truct work s_work; //数据域s truct sjf_work * pNext; //指针域}NODE,*PNODE;void FCFS();void SJF();void showmenu();bool Is_empty(PNODE pHead);int cnt_work(PNODE pHead);PNODE do_work(PNODE pHead,int *w_finish_time,int i);void show(int *w_finish_time,int i,PNODE q,int*w_rel_time);void HRRN();PNODE priorit(PNODE pHead);void do_work_1(PNODE pHead,int *w_finish_time,int i);int main(){i nt choice; //设置选择数s howmenu(); //显示菜单s canf("%d",&choice);w hile(choice != 0) //选择算法{switch(choice){case 1 :printf("您选择的是先来先服务算法:\n");FCFS();break;case 2 :printf("您选择的是短作业优先算法:\n");SJF();break;case 3 :printf("您选择的是高响应比优先调度算法\n");HRRN();break;default:printf("请重新选择！");break;}printf("\n");printf("下面是菜单，请继续，或者按‘0’退出"); showmenu();scanf("%d",&choice);}p rintf("感谢您使用本系统，再见！");r eturn 0;}void FCFS(){i nt j,k;i nt w_rel_time[5];i nt w_finish_time[5];f loat rel_time = 0;struct work temp;i nt i;s truct work w[5];s rand(time(0));f or(i=0;i<5;i++){w[i].id = rand()%10;w[i].arrive_time = rand()%10;w[i].work_time = rand()%10+1;}f or(j=0;j<5;j++){printf("第%d个作业的编号是：%d\t",j+1,w[j].id);printf("第%d个作业到达时间：%d\t",j+1,w[j].arrive_time);printf("第%d个作业服务时间：%d\t",j+1,w[j].work_time);printf("\n");}for(j=1;j<5;j++)for(k=0;k<5-j;k++){if(w[k].arrive_time > w[k+1].arrive_time){temp = w[k];w[k] = w[k+1];w[k+1] = temp;}}printf("\n");w_finish_time[0] = w[0].arrive_time + w[0].work_time;for(j=0;j<5;j++){if(w_finish_time[j] < w[j+1].arrive_time){w_finish_time[j+1] = w[j+1].arrive_time + w[j+1].work_time;}elsew_finish_time[j+1] = w_finish_time[j] +w[j+1].work_time;}for(j=0;j<5;j++)w_rel_time[j] = w_finish_time[j] -w[j].arrive_time;for(j=0;j<5;j++){rel_time += w_rel_time[j];}for(j=0;j<5;j++){printf("第%d个系统执行的作业到达时间：%d ",j+1,w[j].arrive_time);printf("编号是：%d ",w[j].id);printf("服务时间是：%d ",w[j].work_time);printf("完成时间是：%d ",w_finish_time[j]);printf("周转时间是：%d ",w_rel_time[j]);printf("\n");}printf("平均周转时间：%f\n",rel_time/5);}void SJF(){i nt w_rel_time[10];i nt w_finish_time[10];f loat rel_time = 0;s rand(time(0));i nt i;i nt j = 0;P NODE pHead = (PNODE)malloc(sizeof(NODE));i f (NULL == pHead){printf("分配失败, 程序终止!\n");exit(-1);}P NODE pTail = pHead;p Tail->pNext = NULL; //定义该链表有头结点，且第一个节点初始化为空f or(i=0;i<10;i++){PNODE pNew = (PNODE)malloc(sizeof(NODE));if (NULL == pNew){printf("分配失败, 程序终止!\n");exit(-1);}pNew->s_work.id = rand()%100;pNew->s_work.arrive_time = rand()%10;pNew->s_work.work_time = rand()%10+1;pTail->pNext = pNew;pNew->pNext = NULL;pTail = pNew;}P NODE p = pHead->pNext; //p指向第一个节点w hile (NULL != p){printf("第%d个作业的编号是：%d\t",j+1,p->s_work.id);printf("第%d个作业到达时间：%d\t",j+1,p->s_work.arrive_time);printf("第%d个作业服务时间：%d\t",j+1,p->s_work.work_time);printf("\n");p = p->pNext;printf("\n");j++;}p = pHead->pNext;P NODE q = p; //p,q都指向第一个节点p = p->pNext;w hile(p != NULL){if(p->s_work.arrive_time < q->s_work.arrive_time)q = p;p = p->pNext;}P NODE r = pHead->pNext; //r也指向第一个节点i nt cnt = 0; //记录所有节点数据域中到达时间最短且相等的个数w hile(r!= NULL){if( r->s_work.arrive_time == q->s_work.arrive_time ) cnt++;r = r->pNext;}p = pHead->pNext;w hile(p != NULL) //在相等到达时间的作业中找服务时间最短的作业{if(cnt > 1){if( p->s_work.arrive_time ==q->s_work.arrive_time )if( p->s_work.work_time < q->s_work.work_time )q = p;p = p->pNext;}elsep =NULL;} //确定q所指作业最先到达且服务时间最短w_finish_time[0] = q->s_work.arrive_time +q->s_work.work_time;w_rel_time[0] = w_finish_time[0] -q->s_work.arrive_time;p rintf("第1个系统执行的作业到达时间：%d",q->s_work.arrive_time);p rintf("编号是：%d ",q->s_work.id);p rintf("服务时间是：%d \n",q->s_work.work_time); p rintf("完成时间是：%d ",w_finish_time[0]);p rintf("周转时间是：%d \n",w_rel_time[0]);p = pHead; //寻找q的前一个节点，方便删掉q节点w hile( p->pNext != q ){p = p->pNext;}p->pNext = q->pNext;f ree(q);q = NULL;f or(i=0;i<9&&!Is_empty(pHead);i++){printf("现在系统还剩%d个作业！\n",cnt_work(pHead));q = do_work(pHead,w_finish_time,i);show(w_finish_time,i,q,w_rel_time);p = pHead; //寻找q的前一个节点，方便删掉q节点while( p->pNext != q ){p = p->pNext;}p->pNext = q->pNext;free(q);q = NULL;}f or(j=0;j<10;j++)rel_time += w_rel_time[j];}printf("平均周转时间：%f\n",rel_time/10);}bool Is_empty(PNODE pHead) //判断作业是否做完{P NODE p;p = pHead->pNext;i nt len = 0;w hile(p != NULL){len++;p = p->pNext;}i f(len == 0)return true; //当没有作业时，返回为真e lsereturn false;}int cnt_work(PNODE pHead) //计算当前还剩多少作业{P NODE p;p = pHead->pNext;i nt len = 0;w hile(p != NULL){len++;p = p->pNext;}r eturn len;}PNODE do_work(PNODE pHead,int *w_finish_time,int i) {P NODE p,q;i nt cnt = 0; //计数器清0，计算当前作业完成时，系统中有多少个作业已经到达p = pHead->pNext;q = p;w hile(p != NULL){if( p->s_work.arrive_time <= w_finish_time[i] ){cnt ++;q = p;p = p->pNext;}else{p = p->pNext;}} //q指向当前到达时间小于刚刚完成的作业，但不一定是服务时间最短的(如果有的话)p rintf("系统中有%d个作业在当前作业完成时已经到达！\n",cnt);p = pHead->pNext;w hile(p != NULL){if(cnt>1) //执行此次判断后，q现在指向所有条件都满足的作业（如果有的话）{if( p->s_work.arrive_time <= w_finish_time[i] ){if( p->s_work.work_time < q->s_work.work_time ){q = p;p = p->pNext;}elsep = p->pNext;}elsep = p->pNext;}else //当前作业完成时，没有作业到达的情况{p = p->pNext; //用q来接收最先到达的，用p来遍历while( p != NULL ){if( p->s_work.arrive_time<q->s_work.arrive_time )q = p;p = p->pNext;}w_finish_time[i+1] = q->s_work.arrive_time + q->s_work.work_time;}}w_finish_time[i+1] = w_finish_time[i] +q->s_work.work_time;r eturn q;}void show(int *w_finish_time,int i,PNODE q,int*w_rel_time){w_finish_time[i+1] = w_finish_time[i] +q->s_work.work_time;w_rel_time[i+1] = w_finish_time[i+1] -q->s_work.arrive_time;p rintf("第%d个系统执行的作业到达时间：%d",i+2,q->s_work.arrive_time);p rintf("编号是：%d ",q->s_work.id);p rintf("服务时间是：%d\n",q->s_work.work_time);p rintf("完成时间是：%d ",w_finish_time[i+1]);p rintf("周转时间是：%d \n",w_rel_time[i+1]);}void showmenu(){printf("**********************************\n"); p rintf("请选择你要执行的命令~: \n");p rintf("1：先来先服务算法\n");p rintf("2：短作业优先算法\n");p rintf("3: 高响应比优先算法\n");p rintf("0: 退出菜单\n");p rintf("**********************************\n"); }void HRRN(){i nt w_rel_time[10];i nt w_finish_time[10];f loat rel_time = 0;f loat priority; //计算优先权s rand(time(0));i nt i;i nt j = 0;P NODE pHead = (PNODE)malloc(sizeof(NODE));i f (NULL == pHead){printf("分配失败, 程序终止!\n");exit(-1);}P NODE pTail = pHead;p Tail->pNext = NULL; //定义该链表有头结点，且第一个节点初始化为空f or(i=0;i<10;i++) //定义了十个进程{PNODE pNew = (PNODE)malloc(sizeof(NODE));if (NULL == pNew){printf("分配失败, 程序终止!\n");exit(-1);}pNew->s_work.id = rand()%100;pNew->s_work.arrive_time = rand()%10;pNew->s_work.work_time = rand()%10+1;pTail->pNext = pNew;pNew->pNext = NULL;pTail = pNew;}P NODE p = pHead->pNext; //p指向第一个节点w hile (NULL != p){printf("第%d个作业的编号是：%d\t",j+1,p->s_work.id);printf("第%d个作业到达时间：%d\t",j+1,p->s_work.arrive_time);printf("第%d个作业服务时间：%d\t",j+1,p->s_work.work_time);printf("\n");p = p->pNext;printf("\n");j++;}p = pHead->pNext;P NODE q = p; //p,q都指向第一个节点p = p->pNext;w hile(p != NULL){if(p->s_work.arrive_time < q->s_work.arrive_time) q = p;p = p->pNext;}P NODE r = pHead->pNext; //r也指向第一个节点i nt cnt = 0; //记录所有节点数据域中到达时间最短且相等的个数w hile(r!= NULL){if( r->s_work.arrive_time == q->s_work.arrive_time ) cnt++;r = r->pNext;}p = pHead->pNext;w hile(p != NULL) //在相等到达时间的作业中找服务时间最短的作业{if(cnt > 1){if( p->s_work.arrive_time ==q->s_work.arrive_time )if( p->s_work.work_time < q->s_work.work_time )q = p;p = p->pNext;}elsep =NULL;} //确定q所指作业最先到达且服务时间最短w_finish_time[0] = q->s_work.arrive_time +q->s_work.work_time;w_rel_time[0] = w_finish_time[0] -q->s_work.arrive_time;p rintf("第1个系统执行的作业到达时间：%d",q->s_work.arrive_time);p rintf("编号是：%d ",q->s_work.id);p rintf("服务时间是：%d \n",q->s_work.work_time); p rintf("完成时间是：%d ",w_finish_time[0]);p rintf("周转时间是：%d \n",w_rel_time[0]);p = pHead; //寻找q的前一个节点，方便删掉q节点w hile( p->pNext != q ){p = p->pNext;}p->pNext = q->pNext;f ree(q);q = NULL; //已经找到并执行第一个进程，执行完之后又将其删除了f or(i=0;i<9&&!Is_empty(pHead);i++){printf("现在系统还剩%d个作业！\n",cnt_work(pHead));do_work_1(pHead,w_finish_time,i);q = priorit(pHead);show(w_finish_time,i,q,w_rel_time);p = pHead; //寻找q的前一个节点，方便删掉q节点while( p->pNext != q ){p = p->pNext;}p->pNext = q->pNext;free(q);q = NULL;}f or(j=0;j<10;j++){rel_time += w_rel_time[j];}printf("平均周转时间：%f\n",rel_time/10);}void do_work_1(PNODE pHead,int *w_finish_time,int i) {P NODE p,q;i nt cnt = 0; //计数器清0，计算当前作业完成时，系统中有多少个作业已经到达p = pHead->pNext;q = p;w hile(p != NULL){if( p->s_work.arrive_time <= w_finish_time[i] ){cnt ++;q = p;p = p->pNext;}else{p = p->pNext;}} //q指向当前到达时间小于刚刚完成的作业，但有可能有另外几个进程也已经到达了，所以要进行下面的判断p rintf("系统中有%d个作业在当前作业完成时已经到达！\n",cnt);p = pHead->pNext;w hile(p != NULL){if(cnt>1) //说明此时有好几个都已经到达了{if(p->s_work.arrive_time <= w_finish_time[i]){p->s_work.wait = w_finish_time[i] -p->s_work.arrive_time;p = p->pNext;}else{p->s_work.wait = 0;p = p->pNext;}}else //当前作业完成时，没有作业到达的情况{p = p->pNext; //此时p指向第一个节点，q指向第二个节点，还是找最先到达的while( p != NULL ){if( p->s_work.arrive_time <q->s_work.arrive_time )q = p;p = p->pNext;}w_finish_time[i+1] = q->s_work.arrive_time +q->s_work.work_time;return;}}w_finish_time[i+1] = w_finish_time[i] +q->s_work.work_time;}PNODE priorit(PNODE pHead){P NODE p = pHead->pNext;w hile(p != NULL){if(p->s_work.wait > 0){p->s_work.priority = (p->s_work.wait +p->s_work.work_time) / p->s_work.work_time; //计算每一个已经等待的进程的优先等级p = p->pNext;}elsep = p->pNext;}p = pHead->pNext;P NODE q;q = p;p = p->pNext; //p已经指向第二个节点w hile(p != NULL){if(p->s_work.wait > 0){if(p->s_work.priority > q->s_work.priority){q = p;p = p->pNext;}elsep = p->pNext;}elsep = p->pNext;}p rintf("该进程优先级最高，为：%f\n",q->s_work.priority);return q;}实验结果：系统自动为每个算法模拟分配五个作业，同时随机生成作业的编号，作业的到达时间，作业估计运行的时间。
操作系统进程调度实验报告
操作系统进程调度实验报告操作系统进程调度实验报告引言：操作系统是计算机系统中的核心软件之一，负责管理计算机的硬件资源并提供用户与计算机硬件之间的接口。
进程调度作为操作系统的重要功能之一，负责决定哪个进程可以获得处理器的使用权，以及进程如何在处理器上运行。
本实验旨在通过设计和实现一个简单的进程调度算法，加深对操作系统进程调度原理的理解。
一、实验目的本实验的主要目的是通过编写代码模拟操作系统的进程调度过程，掌握进程调度算法的实现方法，深入理解不同调度算法的特点和适用场景。
二、实验环境本实验使用C语言进行编程实现，可在Linux或Windows系统下进行。
三、实验内容1. 进程调度算法的选择在本实验中，我们选择了最简单的先来先服务（FCFS）调度算法作为实现对象。
FCFS算法按照进程到达的先后顺序进行调度，即先到先服务。
这种调度算法的优点是简单易实现，但缺点是无法适应不同进程的执行时间差异，可能导致长作业效应。
2. 进程调度的数据结构在实现进程调度算法时，我们需要定义进程的数据结构。
一个进程通常包含进程ID、到达时间、执行时间等信息。
我们可以使用结构体来表示一个进程，例如：```struct Process {int pid; // 进程IDint arrival_time; // 到达时间int burst_time; // 执行时间};```3. 进程调度算法的实现在FCFS调度算法中，我们需要按照进程到达的先后顺序进行调度。
具体实现时，可以使用一个队列来保存待调度的进程，并按照到达时间的先后顺序将进程入队。
然后，按照队列中的顺序依次执行进程，直到所有进程执行完毕。
4. 实验结果分析通过实现FCFS调度算法，我们可以观察到进程调度的过程和结果。
可以通过输出每个进程的执行顺序、等待时间和周转时间等指标来分析调度算法的效果。
通过比较不同调度算法的指标，可以得出不同算法的优缺点。
四、实验步骤1. 定义进程的数据结构，包括进程ID、到达时间和执行时间等信息。
(完整word版)操作系统作业调度实验报告-多道批处理
计算机学院计算机科学与技术专业07 班姓名学号教师评定_________________实验题目作业调度一、实验目的本实验要求学生模拟作业调度的实现，用高级语言编写和调试一个或多个作业调度的模拟程序，了解作业调度在操作系统中的作用，以加深对作业调度算法的理解。
二、实验内容和要求1、为单道批处理系统设计一个作业调度程序(1)、编写并调试一个单道处理系统的作业调度模拟程序。
(2)、作业调度算法：分别采用先来先服务（FCFS），最短作业优先（SJF）的调度算法。
(3)、由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的CPU时限等因素。
(4)、每个作业由一个作业控制块JCB表示，JCB可以包含如下信息：作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。
作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。
每个作业的最初状态总是等待W。
(5)、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间，并比较各种算法的优缺点。
2、模拟批处理多道操作系统的作业调度（1）写并调试一个作业调度模拟程序。
（2）作业调度算法：分别采用先来服务（FCFS）调度算法。
（3）在批处理系统中，要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求，所需要的资源是否得到满足。
作业调度程序负责从输入井选择若干个作业进入主存，为它们分配必要的资源，当它们能够被进程调度选中时，就可占用处理机运行。
作业调度选择一个作业的必要条件是系统中现有的尚未分配的资源可满足该作业的资源要求。
但有时系统中现有的尚未分配的资源既可满足某个作业的要求也可满足其它一些作业要求，那么，作业调度必须按一定的算法在这些作业中作出选择。
操作系统实验进程调度
实验三进程调度一. 实验目的加深理解并模拟实现进程（作业）调度算法。
1）熟悉常用的进程调度算法, 如FCFS、SPF、FPF、高响应比优先、时间片轮转；2）结合所学的数据结构及编程知识, 选择三种进程调度算法予以实现。
二. 实验属性该实验为设计性实验。
三. 实验仪器设备及器材普通PC386以上微机四. 实验要求本实验要求2学时完成。
1）本实验要求完成如下任务:2）编程实现单处理机系统中的进程调度, 要求从FCFS、SPF、FPF、高响应比优先、时间片轮转算法中至少选择三个；3）最后编写主函数对所做工作进行测试。
实验前应复习实验中所涉及的理论知识和算法, 针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。
实验后认真书写符合规范格式的实验报告（参见附录A）, 并要求用正规的实验报告纸和封面装订整齐, 按时上交。
五: 实验具体设计此程序模拟了两种调度算法, FCFS和SPF, 首先FCFS就是按照进程的创建顺序依次顺序进行, 流程图为：进程顺序执行SPF:每次都进行循环, 选出在该时间刻运行时间最短的进程优先执行。
1.程序代码具体详解:2.创建一结构体作为进程控制器typedef struct PCB{int ID;char state;int arrivetime;int starttime;int finishtime;int servicetime;struct PCB *next;}pcb;定义全局变量作为计时器int time;//计时器创建进程链表:从txt文件中读取数据, 构造一条不含头结点的单链表void Create_process(){ifstream inFile;inFile.open("test.txt");inFile>>n;inFile.get();int i=0;for (;i<n;i++){p=(pcb *)malloc(sizeof(pcb));inFile>>p->ID;inFile>>p->arrivetime;inFile>>p->servicetime;p->starttime=0;p->finishtime=0;p->state='F';p->next=NULL;if(head==NULL){head=p;q=p;time=p->arrivetime;}if(p->arrivetime < time)time=p->arrivetime;q->next=p;q=p;}若执行FCFS算法, 按顺序遍历链表void fcfs1(){int i;p=head;for(i=0;i<n;i++){if(p->state=='F')q=p;run_fcfs1(q);}p=p->next;}}void run_fcfs1(pcb *p1){time = p1->arrivetime > time? p1->arrivetime:time;p1->starttime=time;printf("\n现在时间: %d,开始运行作业%d\n",time,p1->ID);time+=p1->servicetime;p1->state='T';p1->finishtime=time;printf("ID号到达时间开始运行时间服务时间完成时间\n");printf("%d%10d%12d%12d%12d\n",p1->ID,p1->arrivetime,p1->starttime,p1->servicetime,p 1->finishtime);}若执行SPF算法, 每次都从链表头开始遍历链表, 找出arrivetime<=time并且运行时间最短的节点, 执行该节点进程, 最后再删除该节点。
操作系统实验_先来先服务的调度算法和短作业优先
操作系统实验_先来先服务的调度算法和短作业优先先来先服务（FCFS）调度算法是一种非抢占式调度算法，在这种算法中，进程按照到达系统的先后顺序执行，并且在一个进程执行完毕之前，不会有其他进程执行。
如果一个进程没有执行完成，后续进程需要等待。
FCFS调度算法的优点是实现简单，公平性好。
由于按照到达时间先后顺序执行进程，能够保证所有进程都能够得到执行的机会。
然而，FCFS调度算法容易出现“饥饿”现象，即如果一个进程占用了较长的CPU时间，其他进程可能需要等待较长时间。
短作业优先（SJF）调度算法是一种非抢占式调度算法，它选择下一个执行的进程是根据预计的执行时间最短的进程。
在SJF调度算法中，进程按照预计的执行时间进行排序，并按照顺序执行。
SJF调度算法的优点是能够最大程度地减少平均等待时间。
因为进程按照预计的执行时间最短的顺序执行，执行时间短的进程优先执行，可以最大限度地减少其他进程等待的时间。
然而，SJF调度算法需要预先知道所有进程的执行时间，并且如果一个进程执行时间长，其他进程需要等待的时间可能会很长。
FCFS调度算法和SJF调度算法都有各自的优点和局限性。
FCFS调度算法适用于进程执行时间相对均匀的情况，可以保证所有进程都能够得到执行的机会。
但是，如果一个进程执行时间很长，可能会导致其他进程等待的时间非常长，容易出现“饥饿”现象。
SJF调度算法适用于进程执行时间差异较大的情况，可以最大程度地减少平均等待时间。
但是，SJF调度算法需要预先知道所有进程的执行时间，而且在实际应用中，很难准确预测进程的执行时间。
在实验中，可以通过编写相应的模拟程序来实现FCFS调度算法和SJF调度算法。
可以设定一个进程队列，每个进程有自己的到达时间和执行时间。
按照FCFS算法，按照到达时间先后顺序执行进程；按照SJF算法，按照执行时间从小到大的顺序执行进程。
通过模拟进程的调度过程，可以观察到FCFS算法和SJF算法的效果差异。
操作系统实验报告作业调度
操作系统实验报告作业调度作业调度是操作系统中的一个重要组成部分，用于管理和分配计算机系统中的作业，确保系统可靠高效地运行。
作业调度算法的选择直接影响到系统的性能和资源利用率。
本实验通过对不同作业调度算法的理论分析和实际测试，探究它们的特点和优劣，最终找到适合特定场景的作业调度算法。
以下是本次实验的详细报告。
一、实验目的1.理解作业调度算法的原理和功能；2.掌握常用的作业调度算法；3.分析和比较不同作业调度算法的优缺点。
二、实验内容1. FIFO（First In First Out）作业调度算法；2. SJF（Shortest Job First）作业调度算法；3. RR（Round Robin）作业调度算法；4. HRN（Highest Response Ratio Next）作业调度算法。
三、实验过程1.FIFO作业调度算法FIFO算法是最简单的作业调度算法，按照作业提交的先后顺序进行调度。
首先将所有作业按照到达时间排序，然后按照顺序依次执行作业。
2.SJF作业调度算法SJF算法是根据作业的执行时间进行排序，优先执行执行时间最短的作业。
通过比较作业的执行时间，选择最短的作业进行执行。
3.RR作业调度算法RR算法是采用时间片轮转的方式进行调度。
每个作业分配一个时间片，当时间片用完后，将该作业移到队列的末尾继续执行。
时间片的长度可以根据需要进行调整。
4.HRN作业调度算法HRN算法是根据作业的响应比来确定调度顺序。
响应比由作业的等待时间和作业执行时间的比值来计算，响应比越大，优先级越高。
选择响应比最高的作业进行执行。
四、实验结果分析在本实验中，我们通过实际测试不同作业调度算法的性能来进行评估。
测试使用了一组模拟作业集，包括不同的作业执行时间和到达时间。
通过对比不同算法的实际表现1.FIFO算法的优点是简单易实现，但缺点是无法考虑作业的执行时间，因此可能导致平均等待时间较长。
2.SJF算法的优点是能够有效地减少平均等待时间，但缺点是对于长作业可能导致短作业长时间等待。
操作系统进程调度模拟程序实验报告
操作系统进程调度模拟程序实验报告一、实验目的本次实验旨在通过编写一个模拟操作系统进程调度的程序，以加深对进程调度算法的理解。
二、实验内容1. 实现进程相关的数据结构：进程PCB（Process Control Block）。
2.实现进程的创建、撤销以及调度等操作函数。
3. 实现常见的进程调度算法：先来先服务（FCFS）、最短作业优先（SJF）、轮转调度（RR）、优先级调度（Priority）。
4.编写测试程序，验证实现的进程调度算法在不同场景下的表现。
三、实验过程及结果1.进程PCB的设计与实现进程PCB是进程的核心数据结构，用于存储和管理进程相关的信息，包括进程状态（就绪、运行、阻塞）、优先级、执行时间等。
2.进程的创建、撤销及调度函数的实现（1）进程创建函数：实现进程的创建，包括为其分配空间、初始化进程PCB等。
可以根据实际需求，设定进程的优先级、执行时间等属性。
（2）进程撤销函数：实现进程的撤销，包括释放其占用的资源、回收其使用的空间等。
（3）进程调度函数：根据不同的调度算法，实现进程的调度。
可以通过设置时间片大小、优先级设定等方式，实现不同调度算法的效果。
3.进程调度算法的设计与实现（1）先来先服务（FCFS）调度算法：按照进程到达的先后顺序，依次进行调度。
（2）最短作业优先（SJF）调度算法：根据进程的执行时间，选择执行时间最短的进程进行调度。
（3）轮转调度（RR）算法：按照时间片的大小进行调度，每个进程在一个时间片内执行，超过时间片后，暂停并进入等待队列，让其他进程执行。
（4）优先级调度（Priority）算法：根据进程的优先级，选择优先级最高的进程进行调度。
4.测试程序编写测试程序，模拟不同的进程到达顺序、执行时间和优先级等场景，验证不同调度算法的表现。
四、实验结果与分析通过测试程序的运行结果，观察不同调度算法的特点和效果。
可以得出以下结论：1.FCFS算法适用于进程到达时间差异较大的场景，保证了先到先服务。
操作系统实验报告作业调度
操作系统实验报告：作业调度1. 引言作业调度是操作系统中的一个重要概念，它涉及到如何合理地安排计算机系统中的作业执行顺序，以最大程度地提高系统的效率和性能。
本文将介绍作业调度的基本概念和主要算法，以及在实验中的应用。
2. 作业调度的概念作业调度是指根据一定的策略和算法，按照一定的顺序从作业队列中选取作业，将其分配给可用资源来执行的过程。
作业调度的目标是实现公平、高效的任务分配，以提高系统的整体性能。
3. 作业调度算法3.1 先来先服务（FCFS）先来先服务是最简单的作业调度算法，即按照作业提交的顺序来执行。
当一份作业到达系统后，它将被放入作业队列的末尾。
一旦当前执行的作业完成，系统将选择队列中的下一个作业来执行。
3.2 短作业优先（SJF）短作业优先算法是根据作业的执行时间来进行调度，执行时间越短的作业优先级越高。
当一个作业进入系统时，系统会检查队列中的所有作业，并选择执行时间最短的作业来执行。
3.3 优先级调度优先级调度算法是根据作业的优先级来进行调度，优先级越高的作业优先级越高。
每个作业都会被分配一个优先级值，系统会按照优先级从高到低的顺序来执行作业。
3.4 时间片轮转调度时间片轮转调度算法将作业分为多个时间片，每个时间片的执行时间相等。
当一个作业进入系统时，系统会分配给它一个时间片，如果在时间片内作业没有完成，则将其放回队列的末尾，并执行下一个作业。
4. 实验中的应用在操作系统实验中，作业调度是一个重要的实验内容。
通过实验，我们可以深入了解不同调度算法的特点和适用场景。
实验中，我们可以使用模拟器来模拟作业调度的过程。
我们可以创建一个作业队列，然后使用不同的调度算法来执行这些作业，并记录它们的执行时间和系统的吞吐量。
通过实验，我们可以比较不同算法在不同场景下的表现，选择最适合当前系统的作业调度算法。
5. 结论作业调度是一个重要的操作系统概念，它决定了系统的性能和效率。
在本文中，我们介绍了作业调度的基本概念和常用算法，并讨论了在实验中的应用。
操作系统实验报告+进程调度+作业调度等
操作系统实验报告1、进程调度2、作业调度3、主存空间的分配与回收4、文件系统学生学院______计算机学院______ 专业班级____网络工程(3)班_____ 学号______3107007062_____学生姓名________张菲__ _____ 指导教师_______胡欣如 _______2009 年12 月20 日计算机学院网络工程专业3 班_____组、学号3107007062 姓名张菲协作者无教师评定_________________实验题目进程调度一、实验目的用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。
二、实验内容和要求编写并调试一个模拟的进程调度程序，采用“简单时间片轮转法”调度算法对五个进程进行调度。
每个进程有一个进程控制块（ PCB）表示。
进程控制块可以包含如下信息：进程名、到达时间、需要运行时间、已运行时间、进程状态等等。
进程的到达时间及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪 W（Wait）、运行R（Run）两种状态之一。
就绪进程获得 CPU后都只能运行一个时间片。
用运行时间加1来表示。
如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应分配时间片给就绪队列中排在该进程之后的进程，并将它插入就绪队列队尾。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
三、实验主要仪器设备和材料硬件环境：IBM-PC或兼容机软件环境：C语言编程环境四、实验原理及设计方案1、进程调度算法：采用多级反馈队列调度算法。
其基本思想是：当一个新进程进入内在后，首先将它放入第一个队列的末尾，按FCFS原则排队等待高度。
操作系统实验_先来先服务的调度算法和短作业优先
操作系统实验_先来先服务的调度算法和短作业优先操作系统中的进程调度算法是实现多道程序设计的关键，作为操作系统中的调度器，它决定了进程在CPU上执行的顺序，直接影响到系统的性能和响应时间。
本文将重点介绍两种常用的进程调度算法：先来先服务调度算法（FCFS）和短作业优先调度算法（SJF）。
先来先服务调度算法是一种最简单、最基础的调度算法，其实现非常简单：按照进程到达CPU的先后顺序，将其依次调入CPU执行。
当一个进程进入就绪队列后，在CPU空闲的时候，就将其调入CPU执行，直到进程执行完成或者主动放弃CPU时间片。
这种调度算法的优势在于实现简单、公平性好；但其缺点也很明显，由于没有考虑进程的执行时间长短，如果一个长时间的进程先到达就绪队列，则会造成其他进程的等待时间过长，导致系统的响应时间较长。
与FCFS相对的是短作业优先调度算法（Shortest Job First, SJF）。
SJF调度算法会根据进程的相对执行时间长短来进行调度，即将执行时间最短的进程优先调度进入CPU执行。
SJF算法的关键在于如何估计进程的执行时间，通常有两种方法：预测和历史信息。
预测方法是根据进程的相关信息，如进程的大小、执行时间等进行预测；而历史信息方法是根据以往同类任务的执行时间的平均值或历史执行时间进行估算。
在实际操作中，通常采用后者进行调度。
SJF调度算法的优势在于可以最大程度地减少平均等待时间，提高系统的响应效率。
然而，该算法也存在一些问题，如如何准确估算进程的执行时间、对长时间任务不够友好等。
两种调度算法各自都有其优势和劣势，因此在实际操作中需要根据具体的情况选择适用的调度算法。
如果系统中存在大量长时间任务，可以考虑使用FCFS来保证公平性；而如果系统中的任务短且繁琐，可以优先考虑SJF算法来减少平均等待时间。
此外，还有一些改进版的调度算法，如最短剩余时间优先调度算法（Shortest Remaining Time First, SRTF）和多级反馈队列调度算法（Multi-Level Feedback Queue, MLFQ）等，它们在一定程度上兼顾了FCFS和SJF的优势，更适用于实际的操作系统。
操作系统实验报告-批处理系统的作业调度
#include
#include
#include
#include
#include
typedefcharstring[10];/*//定义string为含有10个字符元素的字符数组类型*/
structtask{
stringname;/*作业号*/
intarrtime;/*作业抵达时间*/
操作系统实验报告-批处理系统的作业调度
实验一批处理系统的作业调度
（1）加深对作业概念的理解。
（2）深入细致介绍批处理系统如何非政府作业、管理作业和调度作业。
编写程序完成批处理系统的作业调度，要求采用响应比优先调度算法。
最低积极响应比优先法（hrrn）就是对fcfs方式和sjf方式的一种综合均衡。hrrn调度策略同时考量每个作业的等待时间长短和估算须要的继续执行时间长短，从中挑选出积极响应比最低的作业资金投入继续执行。
printf("%9s%9d%9d%9d%9d%9d%9d\n",
jcb[i].name,jcb[i].arrtime,jcb[i].sertime,
jcb[i].begtime,jcb[i].fintime,jcb[i].turtime,jcb[i].wtutime);
voidcheck()
intstatime,endtime,sumturtime=0.0,sumwtutime=0.0,aveturtime,avewtutime;intcurrent=0,times=0,pre=0;
printf("-------------------------------------------------------------------------\n");
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验作业调度一、实验名称作业调度算法的模拟实现二、实验目标作业调度又称宏观调度，其主要任务是对磁盘设备上大量的后备作业，以一定的原则进行挑选，给选中的作业分配内存等必须的资源，建立其相应的进程，让其投入运行。
本实验要求学生用高级程序设计语言编写和调试一个简化的作业调度程序，模拟实现的调度算法包括：先来先服务调度算法，短作业优先调度算法，响应比高者优先调度算法等，并对这些算法的性能做比较和评价。
以加深学生对作业、作业调度以及作业调度的各种算法的理解。
三、实验环境要求Windows+Visual C++ 6.0；四、实验基本原理作业调度主要是完成作业从后备状态到执行状态的转变，以及从执行状态到完成状态的转变。
（1）创建JCB（作业控制块）：系统在作业进入后备状态时为每个作业创建一个作业控制块（JCB）,从而使该作业可被调度程序感知。
当该作业执行完毕进入完成状态时候，系统自动撤销其JCB 并释放有关资源，进而撤销该作业。
（2）按照作业调度算法，从后备队列中挑选一作业投入运行。
作业调度程序为运行作业建立相应的进程，并分配资源。
（3）主要的作业调度算法包括：先来先服务（FCFS）、短作业优先和最高响应比4）调度策略的指标：最常用的调度性能指标有，周转时间（带权）、吞吐率、响应时间以及设备利用率。
五、数据结构设计（1）作业控制块，包括作业的基本信息描述struct time //时间的数据结构{int hour; intminute;};struct Job //作业{string jobname; time intime; int runtime; time starttime; time endtime; int cycletime; float cltime; bool haverun; //作业名//进入时间//作业估计运行时间//作业开始时间//作业结束时间//作业周转时间//作业带权周转时间//是否已运行};{六、流程图七、源代码#include <iostream>#include <string> using namespace std;struct time //时间的数据结构 {int hour;int minute;};struct Job //作业string jobname; time intime; int runtime; time starttime; time endtime; //作业名 //进入时间 //作业估计运行时间 //作业开始时间//作业结束时间图 1 作业调度算法流程图int cycletime; //作业周转时间float cltime; // 作业带权周转时间bool haverun; //是否已运行};float T=0;// 作业平均周转时间float W=0;// 作业带权平均周转时间void showInput(Job job[],int &n) //输入提示{cout<<"********** 请按作业进入时间先后顺序输入*********"<<endl; for(int i=0;i<n;i++){cout<<"作业"<<i+1<<":"<<endl;cout<<"作业名:";cin>>job[i].jobname;cout<<"作业进入时间:";scanf("%d:%d",&job[i].intime.hour,&job[i].intime.minute);cout<<"作业估计运行时间:";cin>>job[i].runtime; job[i].starttime.hour=0; job[i].starttime.minute=0;job[i].endtime.hour=0; job[i].endtime.minute=0; job[i].cycletime=0;job[i].cltime=0;job[i].haverun=false; //标记为未运行cout<<"<<endl;void Init(Job job[],int &n)// 初始化{for(int i=0;i<n;i++){job[i].starttime.hour=0;job[i].starttime.minute=0;job[i].endtime.hour=0;job[i].endtime.minute=0;job[i].cycletime=0;job[i].cltime=0;job[i].haverun=false; //标记为未运行}T=0;W=0;void showTime(time time) //显示时间{ cout<<time.hour<<":"<<time.minute;}int timeDiff(time t1,time t2) //计算时间差,时间t1 比t2 大{return t1.hour*60+t1.minute-(t2.hour*60+t2.minute);}time timeAdd(time time,int addtime) // 时间相加{time.hour+=addtime/60;time.minute+=addtime%60;if(time.minute>=60){time.hour++;time.minute-=60;}return time;}bool comtime(time t1,time t2)//比较两个时间的大小，第一个大就返回TRUE { if(t1.hour>t2.hour)return true;else if(t1.hour==t2.hour&&t1.minute>=t2.minute)return true;elsereturn false;}void showResult(Job job[],int &n) //显示结果{ cout<<"jobname\tintime\truntime\tsttime\tendtime\t 周转时间(分钟)\t 带权周转时间"<<endl;********"<<endl;for(int i=0;i<n;i++)cout<<job[i].jobname<<"\t"; showTime(job[i].intime);cout<<"\t"<<job[i].runtime<<"\t"; showTime(job[i].starttime);{cout<<"\t";showTime(job[i].endtime);cout<<"\t "<<job[i].cycletime<<"\t\t "<<job[i].cltime<<endl;}cout<<"作业平均周转时间：T="<<T/(n*1.0)<<endl; cout<<"作业带权平均周转时间：W="<<W/(n*1.0)<<endl;}int minRuntime(Job job[],int &n,time &t) // 找出作业中最短作业下标{int min=-1;for(int i=0;i<n;i++){if(job[i].haverun==false && comtime(t,job[i].intime)==true){min=i;break;}}for(int j=min+1;j<n;j++)if(job[j].haverun==false && job[j].runtime<job[min].runtime&& comtime(t,job[j].intime)==true)min=j;return min;}void SJF(Job job[],int &n)// 短作业优先作业调度{struct time t;job[0].starttime.hour=job[0].intime.hour;job[0].starttime.minute=job[0].intime.minute;job[0].endtime=timeAdd(job[0].starttime,job[0].runtime); job[0].haverun=true;job[0].cycletime=timeDiff(job[0].endtime,job[0].intime);job[0].cltime=job[0].cycletime*1.0/job[0].runtime;T+=job[0].cycletime;W+=job[0].cltime;t=job[0].endtime; while(minRuntime(job,n,t)!=-1)int i=minRuntime(job,n,t);if(comtime(job[i].intime,t)) job[i].starttime=job[i].intime;else{job[i].starttime=t;job[i].endtime=timeAdd(job[i].starttime,job[i].runtime); job[i].haverun=true;job[i].cycletime=timeDiff(job[i].endtime,job[i].intime);job[i].cltime=job[i].cycletime*1.0/job[i].runtime; T+=job[i].cycletime;W+=job[i].cltime;t=job[i].endtime;}}int Firstintime(Job job[],int &n) // 找出作业中最先到的{int min=-1;for(int i=0;i<n;i++){if(job[i].haverun==false){min=i;break;}}for(int j=min+1;j<n;j++)if(job[j].haverun==false && comtime(job[min].intime,job[j].intime))min=j;return min;}void FCFS(Job job[],int &n)// 先来先服务作业调度{struct time t;job[0].starttime.hour=job[0].intime.hour;job[0].starttime.minute=job[0].intime.minute;job[0].endtime=timeAdd(job[0].starttime,job[0].runtime); job[0].haverun=true;job[0].cycletime=timeDiff(job[0].endtime,job[0].intime);job[0].cltime=job[0].cycletime*1.0/job[0].runtime; T+=job[0].cycletime;W+=job[0].cltime;t=job[0].endtime;while(Firstintime(job,n)!=-1){int i=Firstintime(job,n);if(comtime(job[i].intime,t))job[i].starttime=job[i].intime;elsejob[i].starttime=t;job[i].endtime=timeAdd(job[i].starttime,job[i].runtime);job[i].haverun=true;job[i].cycletime=timeDiff(job[i].endtime,job[i].intime);job[i].cltime=job[i].cycletime*1.0/job[i].runtime;T+=job[i].cycletime;W+=job[i].cltime;t=job[i].endtime;}}void main(){cout<<"请输入作业数：";int n; //作业数cin>>n;Job *job=new Job[n];if(n<=0){cout<<"输入不合法!";exit(-1);}else{showInput(job,n);cout<<endl;FCFS(job,n);cout<<"先来先服务："<<endl;showResult(job,n);cout<<endl;Init(job,n);SJF(job,n); //短作业优先cout<<"短作业优先："<<endl;showResult(job,n);}system("pause");}八、运行结果用户输入作业的相关信息，程序输出相应的各种算法运行结果。