操作系统实验报告-作业调度
作业调度实验报告
作业调度实验报告一、实验目的1.掌握作业调度的概念和基本原则；2.理解作业调度算法的原理和实现方式；3.熟悉作业调度过程中的各种参数和指标；4.进一步了解操作系统中的进程调度机制。
二、实验环境本次实验使用的操作系统环境为Windows平台。
三、实验内容1.实现一个简单的作业调度算法，根据作业的重要性和执行时间进行优先级排序；2.设计一个作业队列，模拟一系列作业的到达和执行过程；3.根据作业调度算法，将作业分配给CPU执行，并统计作业的等待时间、完成时间等指标；4.进行多次实验，比较不同调度算法之间的性能差异。
四、实验步骤1.首先，设计一个作业类，包括作业的名称、重要性、到达时间和执行时间等属性；2.定义一个作业队列，用于存储到达的作业，并按照到达时间进行排序；3.实现一个简单的作业调度算法，根据作业的重要性和执行时间进行优先级排序；4.设计一个CPU类，用于执行作业队列中的作业，并记录作业的等待时间、完成时间等指标；5.模拟一系列作业的到达和执行过程，将作业调度给CPU执行，并记录相关指标；6.分别使用不同的调度算法进行多次实验，比较各自的性能差异。
五、实验结果与分析通过多次实验，得到了不同调度算法下的作业等待时间、完成时间等指标，并进行了比较。
结果发现，在作业执行时间相同时，按照作业的重要性进行优先级排序的算法，能够使得较重要的作业尽早执行，因而整体的作业等待时间和完成时间较短。
而对于作业执行时间不一致的情况，采用短作业优先算法，可以使作业平均等待时间较短，但在一些较长的作业上可能会存在饥饿现象。
综合考虑作业的重要性和执行时间，采用带权重的优先级队列算法可以获得较好的调度效果。
六、实验总结通过本次实验，我深入了解了作业调度的概念、原理和实现方式。
通过对比不同调度算法的性能差异，对于实际的作业调度过程具有一定的指导意义。
此外，通过实验设计和代码实现，我也提高了编程和分析问题的能力。
总体而言，本次实验使我对操作系统中的作业调度有了更为深刻的理解，并提高了我的实践能力。
操作系统调度算法实验报告
操作系统调度算法实验报告
本实验旨在研究不同操作系统调度算法在实际应用中的表现和影响。
我们选择了三种常见的调度算法进行对比分析，分别是先来先服务（FCFS）、最短作业优先（SJF）和时间片轮转（RR）。
1. 实验准备
在开始实验之前，我们首先搭建了一个简单的模拟环境，包括一个CPU和多个进程。
每个进程具有不同的执行时间，以便模拟不同情况
下的调度效果。
2. 先来先服务（FCFS）
先来先服务是最简单的调度算法之一，即根据进程到达的顺序依次
执行。
实验结果显示，FCFS算法适用于处理大量长作业，但当出现短
作业时会导致平均等待时间较长。
3. 最短作业优先（SJF）
最短作业优先算法会优先执行执行时间最短的进程，以减少平均等
待时间。
在我们的实验中，SJF算法表现出色，尤其在短作业较多的情
况下，能够显著提高系统的响应速度。
4. 时间片轮转（RR）
时间片轮转算法将CPU时间分配给每个进程，每个进程执行一个
时间片后轮转到下一个进程。
然而，RR算法可能导致上下文切换频繁，
影响系统效率。
在实验中，我们发现RR算法在处理多任务时效果较好，但在处理长时间任务时表现一般。
5. 实验总结
通过对三种调度算法的实验比较，我们可以看出不同算法在不同情
况下有着不同的优势和劣势。
在实际应用中，需要根据具体情况选择
合适的调度算法，以提高系统的性能和效率。
希望本实验能为操作系
统调度算法的研究提供一定的参考价值。
操作系统实验报告作业调度
操作系统实验报告作业调度操作系统实验报告：作业调度引言作业调度是操作系统中的重要部分，它负责管理和调度系统中的各种作业，以最大化系统资源的利用率和提高作业的执行效率。
在本次实验中，我们将探讨作业调度的基本原理和实现方法，并通过实验验证其效果。
实验目的本次实验的主要目的是通过实际操作，了解作业调度的基本原理和实现方法，掌握作业调度的相关算法，并通过实验验证其有效性。
实验内容1. 实现作业调度的基本算法在本次实验中，我们将实现作业调度的基本算法，包括先来先服务（FCFS）、最短作业优先（SJF）、优先级调度（Priority Scheduling）和多级反馈队列调度（Multilevel Feedback Queue Scheduling）等。
通过编写代码，模拟这些算法的执行过程，并观察它们的效果。
2. 实验验证我们将设计一些测试用例，通过模拟作业的执行过程，分别使用不同的作业调度算法，并比较它们的执行效果。
通过实验验证，我们将得出不同算法的优劣势，并分析其适用场景。
实验结果经过实验验证，我们得出以下结论：1. 先来先服务（FCFS）算法适用于作业执行时间相对均匀的情况，但可能会导致平均等待时间较长。
2. 最短作业优先（SJF）算法能够最大程度地减少平均等待时间，但可能会出现作业饥饿现象。
3. 优先级调度（Priority Scheduling）算法能够根据作业的优先级进行调度，适用于有明确优先级需求的情况。
4. 多级反馈队列调度（Multilevel Feedback Queue Scheduling）算法能够根据作业的执行情况动态调整优先级，适用于各种类型的作业。
结论作业调度是操作系统中的重要组成部分，不同的作业调度算法适用于不同的场景。
通过本次实验，我们深入了解了作业调度的基本原理和实现方法，掌握了不同算法的优劣势，并通过实验验证了它们的有效性。
这将对我们进一步深入学习操作系统和提高系统性能有着重要的意义。
操作系统——作业调度
操作系统——作业调度实验⼆作业调度模拟程序⼀、⽬的和要求 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. 实验环境本次实验使用的操作系统环境为Linux，并采用C语言进行编码。
3. 实验内容3.1 调度算法1：先来先服务（FCFS）FCFS调度算法是一种简单且常见的调度算法。
该算法按照进程到达的先后顺序进行调度。
在本实验中，我们使用C语言编写代码模拟FCFS算法的调度过程，并记录每个进程的等待时间、周转时间和响应时间。
3.2 调度算法2：最短作业优先（SJF）SJF调度算法是一种非抢占式的调度算法，根据进程的执行时间来选择下一个要执行的进程。
在本实验中，我们使用C语言编写代码模拟SJF算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。
3.3 调度算法3：轮转调度（Round Robin）Round Robin调度算法是一种经典的时间片轮转算法，每个进程在给定的时间片内依次执行一定数量的时间。
如果进程的执行时间超过时间片，进程将被暂时挂起，等待下一次轮转。
在本实验中，我们使用C语言编写代码模拟Round Robin算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。
4. 实验结果分析通过对不同调度算法的模拟实验结果进行分析，可以得出以下结论：- FCFS算法适用于任务到达的先后顺序不重要的场景，但对于执行时间较长的进程可能会导致下一个进程需要等待较久。
- SJF算法适用于任务的执行时间差异较大的场景，能够提高整体执行效率。
- Round Robin算法适用于时间片相对较小的情况，能够公平地为每个进程提供执行时间。
5. 实验总结本次实验通过模拟不同调度算法的实际执行过程，深入了解了各种调度算法的原理、特点和适用场景。
通过对实验结果的分析，我们可以更好地选择合适的调度算法来满足实际应用的需求。
在后续的学习中，我们将进一步探索更多操作系统相关的实验和算法。
作业调度实验报告
作业调度实验报告一、实验目的本次作业调度实验的主要目的是深入理解和掌握作业调度的基本原理和算法，通过实际编程和模拟实验，分析不同调度策略对系统性能的影响，从而为优化作业调度提供理论依据和实践经验。
二、实验环境本次实验在 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）优先级调度算法根据作业的优先级来安排执行顺序。
2023年操作系统作业调度实验报告
实验二作业调度实验题目1、编写并调试一个单道解决系统的作业等待模拟程序。
作业调度算法:分别采用先来先服务（FCFS）,最短作业优先（SJF）的调度算法。
（1 ）先来先服务算法:按照作业提交给系统的先后顺序来挑选作业，先提交的先被挑选。
（2）最短作业优先算法：是以进入系统的作业所提出的“执行时间”为标准,总是优先选取执行时间最短的作业。
二.实验目的：本实验规定用高级语言（C语言实验环境）编写和调试一个或多个作业调度的模拟程序，了解作业调度在操作系统中的作用，以加深对作业调度算法的理解三.实验过程〈一〉单道解决系统作业调度1）单道解决程序作业调度实验的源程序:zuoye.c 执行程序：zu o y e.exe2）实验分析：1、由于在单道批解决系统中，作业一投入运营，它就占有计算机的一切资源直到作业完毕为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的CP U时限等因素。
2、每个作业由一个作业控制块JCB表达,JCB可以包含如下信息:作业名、提交时间、所需的运营时间、所需的资源、作业状态、链指针等等。
作业的状态可以是等待W（Wait）、运营R（Run）和完毕F（Finish）三种状态之一。
每个作业的最初状态else i f (p->n e e d time<min->need t ime) m in=p； p= p ->next；( while (p!=NULL);i f (iden) {i—；/ / pr i n tf ("\nt i m e =%d: \ t no JCB sub mib.. . wait . . . t ime);tim e s++；i f ( times> 10 0) {prin t f("\nru n t ime i s too Ion g . .. error z，) ;g etc h () ； ))e 1 s e{ru n ning(m i n, m) ；//调用running ()函数}} //forf i na 1 (); 〃调用r u nn i ng()函数)voi d fefs (int m)〃先来先服务算法(int i, iden;syst e m ("cl s ");i ni t a 1 ();f or(i=0;i<n;i++)(p= r ea d y； i d en=l;do{if (p-> s tate= = , W* & &p ->reach t i me<=t i mes) i d e n=0：i f (i d e n )p= p -> n ext;}while(p!=NULL&&iden);if (i d on){i——；prin tf(〃\ n没有满足规定的进程，需等待”)；t imes++;i f (time s >1 0 0 ) {prin t f ("\n 时间过长")；getch () ;})e 1 se{runn i ng(p, m); 〃调用r u nn i n g ()函数))final () ;//调用ru n n i n g ()函数}void muneO{int m;s y s tem (〃 c 1 s〃)；p r i n t f (z/\ n\n\t\t *** 火 * ****** * ***** * ***** *** *** * *** * **** ***** **\ t \ t\n ");P rintf ('\t \ t \ t\t 作业调度演示\ n ")；pr i ntf( " \t\t^ ***** * * *** * *** * ******** * * **** * ******** * * *** * \t\P r intf(*\n\n\n\t\ t \tl.先来先服务算法.;pr i nt f ("\n\t\ t \ t2.最短作业优先算法.;printfC\n\ t \ t \t3.响应比高者优先算法");prin t f ( ° \0.退出程序.;P rintfC \n\n\t \t\ t \t 选择所要操作:");s c anf (*%d*, &m);sw i tc h (m)(c ase 1:f c f s (m);getchO ；s y stem("c 1 s");mune();brea k ;c a se 2 :sjf (m):getch ();system ( " cis*)；mune ();break；case 3 :hr n (m);g e t c h ();sys t em("cls");mune ()；br e a k ；case 0:system ("cis");break;d e f a u 1 t :pr intf(〃选择错误，重新选择getchO ;system ("c Is");muneO ;))main ()//主函数(i niz e ();muneO ;)5)调试结果：i.选择操作的界面程课件'计算机操作系统联作系统实验八作业调度\zuoye.exe ，作业调度演示.先来先服务算法.1 .最短企业优先算法.2 .响应居意者优先萱法 4战出程序.选择所要操作:2.输入操作初始信息:c 「E:\课程课件'计算机》3 .先来先服务算法作业调度结果：（调度顺序：a -> b ->c->d->e ）输入作业数：5输入作业数：5太人作业名:a7、侬、|到达时间:0要运行的时间：4 必法崎松时间其要运行的时间：3植入作业名:c 作业默认到达时间:2 曲人作批要运行的时间;5 植入作业名:d 伟业默认到达时间：3 曲入作要运行的时间;2 检入作业名:e 伟业默认到达时间;4 输入作业要运行的时间;4作业证在运行，估计其运行情况: 开始运宜时刻：。
作业调度算法(先来先服务算法,短作业算法)
《操作系统》实验报告题目：作业调度算法班级：网络工程姓名：朱锦涛学号：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;}实验结果：系统自动为每个算法模拟分配五个作业，同时随机生成作业的编号，作业的到达时间，作业估计运行的时间。
操作系统实验报告作业调度
操作系统实验报告作业调度操作系统实验报告：作业调度引言：操作系统是计算机系统中最核心的软件之一，它负责管理计算机的资源，为用户提供良好的使用环境。
在操作系统中，作业调度是非常重要的一部分，它决定了计算机如何合理地分配和调度各个作业的执行顺序，以提高计算机的效率和性能。
本实验报告将介绍作业调度的概念、调度算法以及实验结果。
一、作业调度的概念作业调度是指根据一定的策略和算法，将就绪队列中的作业按照一定的顺序分配给处理器，使得计算机系统能够充分利用资源，提高系统的吞吐量和响应时间。
作业调度的目标是实现公平性、高效性和平衡性。
二、作业调度的算法1. 先来先服务（FCFS）调度算法FCFS调度算法是最简单的调度算法之一，它按照作业的到达顺序进行调度，先到达的作业先执行。
这种算法的优点是简单易实现，但是可能会导致长作业等待时间过长，造成资源浪费。
2. 最短作业优先（SJF）调度算法SJF调度算法是根据作业的执行时间来进行调度，执行时间短的作业先执行。
这种算法能够最大程度地减少平均等待时间，提高系统的响应速度，但是可能会导致长作业长时间等待。
3. 优先级调度算法优先级调度算法是根据作业的优先级来进行调度，优先级高的作业先执行。
这种算法可以根据不同的需求设置不同的优先级，但是可能会导致低优先级的作业长时间等待。
4. 时间片轮转调度算法时间片轮转调度算法是将处理器的执行时间划分为多个时间片，每个作业在一个时间片内执行，时间片用完后，将处理器分配给下一个作业。
这种算法可以实现公平性，但是可能会导致长作业等待时间过长。
三、实验结果与分析在本次实验中，我们使用了不同的作业调度算法，并对其进行了性能测试。
测试结果显示，FCFS算法在平均等待时间方面表现较差，而SJF算法和优先级调度算法在平均等待时间方面表现较好。
时间片轮转调度算法能够实现公平性，但是可能会导致长作业等待时间过长。
结论：作业调度是操作系统中的重要组成部分，合理的作业调度算法能够提高计算机系统的效率和性能。
操作系统实验进程调度
实验三进程调度一. 实验目的加深理解并模拟实现进程（作业）调度算法。
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并且运行时间最短的节点, 执行该节点进程, 最后再删除该节点。
操作系统实验报告-作业调度
作业调度一、实验目的1、对作业调度的相关内容作进一步的理解。
2、明白作业调度的主要任务。
3、通过编程掌握作业调度的主要算法。
二、实验内容及要求1、对于给定的一组作业, 给出其到达时间和运行时间，例如下表所示：作业名 A B C D E F到达时间0 2 5 5 12 15服务时间 6 50 20 10 40 82、分别用先来先服务算法、短作业优先和响应比高者优先三种算法给出作业的调度顺序。
3、计算每一种算法的平均周转时间及平均带权周转时间并比较不同算法的优劣。
三、主要算法流程图开始响应比高者优先短作业优先先来先服务算法生成调度顺序队列计算平均周转时间及平均带权周转时间结束退出系统YN四、测试数据及运行结果测试数据workA={'作业名':'A','到达时间':0,'服务时间':6} workB={'作业名':'B','到达时间':2,'服务时间':50} workC={'作业名':'C','到达时间':5,'服务时间':20} workD={'作业名':'D','到达时间':5,'服务时间':10} workE={'作业名':'E','到达时间':12,'服务时间':40} workF={'作业名':'F','到达时间':15,'服务时间':8}运行结果先来先服务算法调度顺序:['A', 'B', 'C', 'D', 'E', 'F'] 周转时间:74.1666666667 带权周转时间:4.83333333333短作业优先算法调度顺序:['A', 'D', 'F', 'C', 'E', 'B']周转时间:44.8333333333带权周转时间:1.166********响应比高者优先算法调度顺序:['A', 'D', 'F', 'E', 'C', 'B']周转时间:48.1666666667带权周转时间:1.5五、代码#encoding=gbkworkA={'作业名':'A','到达时间':0,'服务时间':6,'结束时间':0,'周转时间':0,'带权周转时间':0}workB={'作业名':'B','到达时间':2,'服务时间':50}workC={'作业名':'C','到达时间':5,'服务时间':20}workD={'作业名':'D','到达时间':5,'服务时间':10}workE={'作业名':'E','到达时间':12,'服务时间':40}workF={'作业名':'F','到达时间':15,'服务时间':8}list1=[workB,workA,workC,workD,workE,workF]list2=[workB,workA,workC,workD,workE,workF]list3=[workB,workA,workC,workD,workE,workF]#先来先服务算法def fcfs(list):resultlist = sorted(list, key=lambda s: s['到达时间'])return resultlist#短作业优先算法def sjf(list):time=0resultlist=[]for work1 in list:time+=work1['服务时间']listdd=[]ctime=0for i in range(time):for work2 in list:if work2['到达时间']<=ctime:listdd.append(work2)if len(listdd)!=0:li = sorted(listdd, key=lambda s: s['服务时间'])resultlist.append(li[0])list.remove(li[0])ctime+=li[0]['服务时间']listdd=[]return resultlist#响应比高者优先算法def hrrn(list):time=0resultlist=[]for work1 in list:time+=work1['服务时间']listdd=[]ctime=0for i in range(time):for work2 in list:if work2['到达时间']<=ctime:work2['等待时间']=ctime-work2['到达时间']listdd.append(work2)if len(listdd)!=0:li = sorted(listdd, key=lambda s: (s['等待时间']+s['服务时间'])/s['服务时间'])resultlist.append(li[-1])list.remove(li[-1])ctime+=li[-1]['服务时间']listdd=[]return resultlist#调度顺序def shunxu(resultlist,miaoshu):print(miaoshu)ddsx=[]for work in resultlist:for d,x in work.items():if d.decode('gb2312')==u'作业名':ddsx.append(x)#print d.decode('gb2312')+":"+str(x) print(u'调度顺序:'+str(ddsx))turnaroundTime(resultlist)#平均周转时间及平均带权周转时间def turnaroundTime(resultlist):time=0for work in resultlist:work['结束时间']=work['服务时间']+timetime=work['结束时间']work['周转时间']=work['结束时间']-work['到达时间']work['带权周转时间']=work['周转时间'] / work['服务时间'] zzsj=0dqzzsj=0for work in resultlist:zzsj+=work['周转时间']dqzzsj+=work['带权周转时间']print('周转时间:'+str(zzsj*1.0/len(resultlist)))print('带权周转时间:'+str(dqzzsj*1.0/len(resultlist)))print('')shunxu(fcfs(list1),'先来先服务算法') shunxu(sjf(list2),'短作业优先算法') shunxu(hrrn(list3),'响应比高者优先算法')。
操作系统实验报告之作业调度算法
操作系统实验五：作业调度算法时间：2013-12-27地点：计算机实验机房2实验人：朱蓉蓉学号：E01114336本次实验主要是进行先来先服务调度算法、短作业优先调度算法、高优先权优先调度算法的编程。
实验代码如下：#include <iostream.h>#include <stdio.h>#include <string.h>void FCFS(); //先来先服务void SJF(); //短作业优先void FPF(); //高优先权void input(); //输入函数void operation(); //运算输出函数int n; //全局变量作业输入量double avturn; //平均周转时间double avdqzz; //平均带权周转时间double t=0.0,k=0.0; //全局变量用来表示总的周转时间和总的带权周转时间struct HomeWork{int num; //作业号char name; //进程名double arrivetime; //到达时间double servetime; //服务时间double begintime; //开始时间double endtime; //完成时间double turntime; //周转时间double dqzztime; //带权周转时间double zgxy; //最高响应比}HW[10];void input(){cout<<"请输入要执行作业的数量："<<endl;cin>>n;for(int i=1;i<=n;i++){cout<<"请输入第"<<i<<"个作业的数据："<<endl;HW[i].num=i;cout<<"进程名：";cin>>HW[i].name;cout<<"到达时间：";cin>>HW[i].arrivetime;cout<<"服务时间：";cin>>HW[i].servetime;}}void operation(){for(int i=1;i<=n;i++){if(i==1)HW[i].begintime=HW[i].arrivetime; //如果是第一个作业开始时间就是到达时间elseHW[i].begintime=HW[i-1].endtime;//如果不是，则作业的开始时间是前一个的结束时间HW[i].endtime=HW[i].begintime+HW[i].servetime;HW[i].turntime=HW[i].endtime-HW[i].arrivetime;HW[i].dqzztime=HW[i].turntime/HW[i].servetime;}for(i=1;i<=n;i++){t=t+HW[i].turntime;k=k+HW[i].dqzztime;}avturn=t/n;avdqzz=k/n;cout<<"作业序号进程名到达时间服务时间开始时间完成时间周转时间带权周转时间 "<<endl;for(i=1;i<=n;i++)cout<<" "<<HW[i].num<<" "<<HW[i].name<<" \t"<<HW[i].arrivetime<<" \t"<<HW[i].servetime<<" \t"<<HW[i].begintime<<" \t"<<HW[i].endtime<<" \t"<<HW[i].turntime<<" \t"<<HW[i].dqzztime<<endl;cout<<"平均周转时间："<<avturn<<endl;cout<<"平均带权周转时间："<<avdqzz<<endl;}void FCFS(){cout<<"\n*********************先来先服务（FCFS）算法*********************\n";operation();t=0.0;k=0.0;}void SJF(){cout<<"\n*********************短作业优先（SJF）算法*********************\n";int no; //作业号double tjtime; //提交时间double zxtime; //执行时间for(int i=2;i<=n;i++)for(int j=i+1;j<=n;j++){if(HW[i].servetime>HW[j].servetime){no=HW[i].num;HW[i].num=HW[j].num;HW[j].num=no; //作业号互换tjtime=HW[i].arrivetime;HW[i].arrivetime=HW[j].arrivetime;HW[j].arrivetime=tjtime; //作业到达时间互换zxtime=HW[i].servetime;HW[i].servetime=HW[j].servetime;HW[j].servetime=zxtime; //作业服务时间互换}}operation();t=0.0;k=0.0;}void FPF(){cout<<"\n*********************高优先权优先调度算法*********************\n";double tjtime,zxtime;int no;for(int i=2;i<=n;i++){if(HW[i].arrivetime<HW[i-1].endtime)//判断第二个作业是否是在第一个作业完成前提交的HW[i].zgxy=(HW[i-1].endtime-HW[i].arrivetime)/HW[i].servetime +1;for(int j=i+1;j<=n;j++){if(HW[j].arrivetime<HW[i].endtime)//判断后面作业是否是前一个作业完成前提交的HW[j].zgxy=(HW[j].begintime-HW[j].arrivetime)/HW[j].servetime +1;if(HW[i].zgxy<HW[j].zgxy){no=HW[i].num;HW[i].num=HW[j].num;HW[j].num=no; //作业号互换tjtime=HW[i].arrivetime;HW[i].arrivetime=HW[j].arrivetime;HW[j].arrivetime=tjtime; //作业提交时间互换zxtime=HW[i].servetime;HW[i].arrivetime=HW[j].arrivetime;HW[j].arrivetime=zxtime; //作业执行时间互换}}}operation();t=0.0;k=0.0;}void main(){input();FCFS();SJF();FPF();}实验结果截图：第一组数据：第二组数据：。
操作系统实验报告作业调度
操作系统实验报告作业调度作业调度是操作系统中的一个重要组成部分，用于管理和分配计算机系统中的作业，确保系统可靠高效地运行。
作业调度算法的选择直接影响到系统的性能和资源利用率。
本实验通过对不同作业调度算法的理论分析和实际测试，探究它们的特点和优劣，最终找到适合特定场景的作业调度算法。
以下是本次实验的详细报告。
一、实验目的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. 引言作业调度是操作系统中的一个重要概念，它涉及到如何合理地安排计算机系统中的作业执行顺序，以最大程度地提高系统的效率和性能。
本文将介绍作业调度的基本概念和主要算法，以及在实验中的应用。
2. 作业调度的概念作业调度是指根据一定的策略和算法，按照一定的顺序从作业队列中选取作业，将其分配给可用资源来执行的过程。
作业调度的目标是实现公平、高效的任务分配，以提高系统的整体性能。
3. 作业调度算法3.1 先来先服务（FCFS）先来先服务是最简单的作业调度算法，即按照作业提交的顺序来执行。
当一份作业到达系统后，它将被放入作业队列的末尾。
一旦当前执行的作业完成，系统将选择队列中的下一个作业来执行。
3.2 短作业优先（SJF）短作业优先算法是根据作业的执行时间来进行调度，执行时间越短的作业优先级越高。
当一个作业进入系统时，系统会检查队列中的所有作业，并选择执行时间最短的作业来执行。
3.3 优先级调度优先级调度算法是根据作业的优先级来进行调度，优先级越高的作业优先级越高。
每个作业都会被分配一个优先级值，系统会按照优先级从高到低的顺序来执行作业。
3.4 时间片轮转调度时间片轮转调度算法将作业分为多个时间片，每个时间片的执行时间相等。
当一个作业进入系统时，系统会分配给它一个时间片，如果在时间片内作业没有完成，则将其放回队列的末尾，并执行下一个作业。
4. 实验中的应用在操作系统实验中，作业调度是一个重要的实验内容。
通过实验，我们可以深入了解不同调度算法的特点和适用场景。
实验中，我们可以使用模拟器来模拟作业调度的过程。
我们可以创建一个作业队列，然后使用不同的调度算法来执行这些作业，并记录它们的执行时间和系统的吞吐量。
通过实验，我们可以比较不同算法在不同场景下的表现，选择最适合当前系统的作业调度算法。
5. 结论作业调度是一个重要的操作系统概念，它决定了系统的性能和效率。
在本文中，我们介绍了作业调度的基本概念和常用算法，并讨论了在实验中的应用。
作业调度系统实验报告
一、实验目的1. 理解作业调度系统的基本原理和流程。
2. 掌握作业调度算法的设计与实现。
3. 评估不同作业调度算法的性能。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.73. 开发工具：PyCharm三、实验内容1. 作业调度系统概述2. 作业调度算法设计3. 作业调度系统实现4. 性能评估与分析四、实验步骤1. 作业调度系统概述（1）作业调度系统定义：作业调度系统是计算机系统中负责将作业分配到各个处理器（CPU）进行执行的部分。
（2）作业调度系统功能：作业调度系统负责接收作业、分析作业、选择作业执行、监控作业执行、处理作业异常等。
2. 作业调度算法设计（1）先来先服务（FCFS）算法：按照作业提交的顺序进行调度。
（2）短作业优先（SJF）算法：优先调度预计运行时间最短的作业。
（3）最高响应比优先（HRRN）算法：综合考虑作业的等待时间和估计运行时间，优先调度响应比最高的作业。
（4）轮转调度（RR）算法：将作业分配到各个处理器进行执行，每个处理器分配固定的时间片，时间片结束后进行抢占调度。
3. 作业调度系统实现（1）创建作业类：定义作业的属性，如作业ID、预计运行时间、实际运行时间等。
（2）创建调度器类：实现作业调度算法，包括作业接收、分析、选择、监控和异常处理等功能。
（3）创建处理器类：模拟CPU执行作业，记录作业执行时间。
（4）创建模拟环境：模拟多个作业提交到系统中，调度器根据算法进行调度，处理器执行作业。
4. 性能评估与分析（1）性能指标：平均等待时间、平均周转时间、吞吐量等。
（2）评估方法：通过模拟不同作业调度算法在相同作业集合下的性能，对比分析其优缺点。
（3）结果分析：根据实验结果，分析不同作业调度算法在处理不同作业集合时的性能表现。
五、实验结果与分析1. FCFS算法（1）平均等待时间：20ms（2）平均周转时间：25ms（3）吞吐量：0.82. SJF算法（1）平均等待时间：15ms（2）平均周转时间：20ms（3）吞吐量：0.93. HRRN算法（1）平均等待时间：18ms（2）平均周转时间：23ms（3）吞吐量：0.854. RR算法（1）平均等待时间：17ms（2）平均周转时间：22ms（3）吞吐量：0.86根据实验结果，SJF算法在处理短作业集合时具有较好的性能，平均等待时间和周转时间较短；而FCFS算法在处理长作业集合时性能较好，平均等待时间和周转时间较长。
操作系统实验报告-批处理系统的作业调度
#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. 实验环境•操作系统：Linux•编程语言：Python•实验工具：CPU模拟器3. 实验原理作业调度是操作系统中的一个重要环节，主要负责将用户提交的作业按照一定的策略分配到CPU上执行。
作业调度的主要目标是提高CPU的利用率，缩短作业的平均等待时间，提高系统的吞吐量。
常用的作业调度算法有先来先服务（FCFS）、短作业优先（SJF）、最短剩余时间优先（SRT）等。
4. 实验内容本次实验主要分为两个部分：一是实现作业调度算法，二是对不同算法进行性能分析。
4.1 作业调度算法实现以先来先服务（FCFS）算法为例，实现作业调度如下：```pythonclass Job:def __init__(self, job_id, arrival_time, execute_time):self.job_id = job_idself.arrival_time = arrival_timeself.execute_time = execute_timeclass JobScheduler:def __init__(self):self.jobs = []def add_job(self, job):self.jobs.append(job)def schedule(self):start_time = 0finish_time = 0for job in self.jobs:if job.arrival_time >= start_time:start_time = job.arrival_timefinish_time = start_time + job.execute_timeprint(f"Job {job.job_id} arrives at {start_time} and finishes a t {finish_time}")start_time = finish_timeif name== “main”:scheduler = JobScheduler()scheduler.add_job(Job(1, 0, 5))scheduler.add_job(Job(2, 1, 3))scheduler.add_job(Job(3, 3, 8))scheduler.schedule()4.2 性能分析通过对不同作业调度算法的模拟运行，分析其性能指标，如平均等待时间、平均响应时间、吞吐量等。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
作业调度
一、实验目的
1、对作业调度的相关内容作进一步的理解。
2、明白作业调度的主要任务。
3、通过编程掌握作业调度的主要算法。
二、实验内容及要求
1、对于给定的一组作业, 给出其到达时间和运行时间，例如下表所示：
2、分别用先来先服务算法、短作业优先和响应比高者优先三种算法给出作业的调度顺序。
3、计算每一种算法的平均周转时间及平均带权周转时间并比较不同算法的优劣。
测试数据
workA={'作业名':'A','到达时间':0,'服务时间':6} workB={'作业名':'B','到达时间':2,'服务时间':50} workC={'作业名':'C','到达时间':5,'服务时间':20} workD={'作业名':'D','到达时间':5,'服务时间':10} workE={'作业名':'E','到达时间':12,'服务时间':40} workF={'作业名':'F','到达时间':15,'服务时间':8}
运行结果
先来先服务算法
调度顺序:['A', 'B', 'C', 'D', 'E', 'F']
周转时间:
带权周转时间:
短作业优先算法
调度顺序:['A', 'D', 'F', 'C', 'E', 'B']
周转时间:
带权周转时间:1.
响应比高者优先算法
调度顺序:['A', 'D', 'F', 'E', 'C', 'B']
周转时间:
带权周转时间:
五、代码
#encoding=gbk
workA={'作业名':'A','到达时间':0,'服务时间':6,'结束时间':0,'周转时间':0,'带权周转时间':0}
workB={'作业名':'B','到达时间':2,'服务时间':50}
workC={'作业名':'C','到达时间':5,'服务时间':20}
workD={'作业名':'D','到达时间':5,'服务时间':10}
workE={'作业名':'E','到达时间':12,'服务时间':40}
workF={'作业名':'F','到达时间':15,'服务时间':8}
list1=[workB,workA,workC,workD,workE,workF]
list2=[workB,workA,workC,workD,workE,workF]
list3=[workB,workA,workC,workD,workE,workF]
#先来先服务算法
def fcfs(list):
resultlist = sorted(list, key=lambda s: s['到达时间'])
return resultlist
#短作业优先算法
def sjf(list):
time=0
resultlist=[]
for work1 in list:
time+=work1['服务时间']
listdd=[]
ctime=0
for i in range(time):
for work2 in list:
if work2['到达时间']<=ctime:
(work2)
if len(listdd)!=0:
li = sorted(listdd, key=lambda s: s['服务时间'])
(li[0])
(li[0])
ctime+=li[0]['服务时间']
listdd=[]
return resultlist
#响应比高者优先算法
def hrrn(list):
time=0
resultlist=[]
for work1 in list:
time+=work1['服务时间']
listdd=[]
ctime=0
for i in range(time):
for work2 in list:
if work2['到达时间']<=ctime:
work2['等待时间']=ctime-work2['到达时间']
(work2)
if len(listdd)!=0:
li = sorted(listdd, key=lambda s: (s['等待时间']+s['服务时间'])/s['服务时间'])
(li[-1])
(li[-1])
ctime+=li[-1]['服务时间']
listdd=[]
return resultlist
#调度顺序
def shunxu(resultlist,miaoshu):
print(miaoshu)
ddsx=[]
for work in resultlist:
for d,x in ():
if ('gb2312')==u'作业名':
(x)
#print ('gb2312')+":"+str(x)
print(u'调度顺序:'+str(ddsx))
turnaroundTime(resultlist)
#平均周转时间及平均带权周转时间
def turnaroundTime(resultlist):
time=0
for work in resultlist:
work['结束时间']=work['服务时间']+time
time=work['结束时间']
work['周转时间']=work['结束时间']-work['到达时间']
work['带权周转时间']=work['周转时间'] / work['服务时间']
zzsj=0
dqzzsj=0
for work in resultlist:
zzsj+=work['周转时间']
dqzzsj+=work['带权周转时间']
print('周转时间:'+str(zzsj*len(resultlist)))
print('带权周转时间:'+str(dqzzsj*len(resultlist))) print('')
shunxu(fcfs(list1),'先来先服务算法')
shunxu(sjf(list2),'短作业优先算法')
shunxu(hrrn(list3),'响应比高者优先算法')。