操作系统——移动臂调度算法的实现

移臂调度算法移臂调度算法一、实验目的作为操作系统的辅助存储器，用来存放文件的磁盘是一类高速大容量旋转型存储设备，在繁重的I/O设备负载下，同时会有若干传输请求来到并等待处理，系统必须采用一种调度策略，能够按最佳次序执行要求访问的诸多请求，这叫做驱动调度，所使用的算法叫做驱动调度算法。

驱动调度算法能减少为若干I/O请求服务所需消耗的总时间，从而提高系统效率。

对于磁盘设备，在启动之前按驱动调度策略对访问的请求优化其排序十分必要。

除了使旋转圈数达到最少的调度策略外，还应考虑使移动臂的移动时间最短的调度策略。

二、实验要求书写实验报告，应该包括以下几项内容:(1)实验题目；(2)程序中使用的数据结构及主要符号说明；(3)程序流程图和带有注释的源程序；(4)执行程序名，并打印程序运行时的初值和运行结果；(5)通过实验后的收获与体会及对实验的改进意见和见解。

三、程序及主要符号说明(1)先来先服务(FCFS)这是一种简单的磁盘调度算法。

它根据进程请求访问磁盘的先后次序进行调度。

此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。

但此算法由于未对寻道进行优化，致使平均寻道时间可能较长。

(2)最短寻道时间优先(SSTF)该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，但这种调度算法却不能保证平均寻道时间最短。

(3)扫描算法(SCAN)SCAN算法不仅考虑到欲访问的磁道与当前磁道的距离，更优先考虑的是磁头的当前移动方向。

例如，当磁头正在自里向外移动时,SCAN算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外，又是距离最近的。

这样自里向外地访问，直到再无更外的磁道需要访问才将磁臂换向，自外向里移动。

这时，同样也是每次选择这样的进程来调度，即其要访问的磁道，在当前磁道之内，从而避免了饥饿现象的出现。

由于这种算法中磁头移动的规律颇似电梯的运行，故又称为电梯调度算法。

操作系统磁头引臂调度算法操作系统的磁头引臂调度算法是磁盘调度算法的一种，用于管理磁盘访问请求的顺序，以提高磁盘I/O系统的性能。

在操作系统中，磁道是磁盘表面上的一个圆环，磁头是读写磁道上数据的设备。

磁头引臂用于支撑磁头，并将磁头移动到不同的磁道上进行读写操作。

磁头引臂调度算法的目标是最小化磁头移动的时间，以减少访问延迟并提高磁盘的吞吐量。

常见的磁头引臂调度算法有以下几种：1.先来先服务算法（FCFS）：该算法将磁盘请求按照它们到达磁盘的顺序进行服务。

虽然该算法实现简单，但是可能会导致磁头在不同的磁道上频繁移动，从而降低磁盘I/O系统的性能。

2.最短寻道时间优先算法（SSTF）：该算法选择离当前磁头位置最近的磁道进行服务。

这样可以最小化磁头移动的距离，从而提高磁盘I/O系统的性能。

然而，该算法可能会导致一些请求一直等待，从而产生饥饿现象。

3.扫描算法（SCAN）：该算法将磁头按照一个方向移动，直到到达最外或最内磁道。

然后，磁头方向改变，并在返回的过程中服务等待的磁道请求。

这样可以通过服务等待请求来减少移动距离。

然而，该算法可能会导致一些请求等待时间较长。

4.循环扫描算法（C-SCAN）：该算法类似于扫描算法，但是在磁头到达一端后，直接返回到另一端并重新开始。

这样可以避免一些请求长时间等待。

5.电梯算法（LOOK）：该算法类似于扫描算法，但是在磁头到达一端后，不直接返回，而是只服务等待的磁道请求。

这样可以减少磁头移动的距离，并提高磁盘I/O 的吞吐量。

以上是常见的磁头引臂调度算法，它们各有优劣。

在实际应用中，选择合适的磁头引臂调度算法取决于具体的应用场景和需求。

一般来说，SSTF算法和LOOK算法是应用较广泛的磁头引臂调度算法，它们相对简单而且能够提供较好的性能。

值得注意的是，随着技术的发展，新的磁盘调度算法也在不断涌现，例如基于预测磁盘访问模式的算法（如SSF和C-SCAN-EDF算法）以及基于套接字的磁盘调度算法（如HybridSCAN算法）。

0、磁盘的驱动调度有“移臂调度”和“旋转调度”两部分组成。

常用的移臂调度算法有：先来先服务算法最短寻找时间优先算法电梯调度算法单向扫描算法。

(要注意题目要求的是哪种算法，求总移动距离还是平均移动距离)假设柱面的编号从0到199。

例如，如果现在读写磁头正在53号柱面上执行输入输出操作，而等待访问者依次要访问的柱面为98，183，37，122，14，124，65，67。

(1)．先来先服务调度算法当53号柱面上的操作结束后，访问柱面的次序为98，183，37，122，14，124，65，67。

读写磁头总共移动了640个柱面的距离。

(从53开始，每次移动距离之和，平均移动距离是640/8=80个柱面)(2)．最短寻找时间优先调度算法现在当53号柱面的操作结束后，访问次序为65、67、37、14，98，122，124，183。

读写磁头总共移动了236个柱面的距离。

(从53开始，每次找距离当前最近的进行移动)(3) 电梯调度算法由于该算法是与移动臂的方向有关，所以，应分两种情况来讨论。

(i)移动臂先向外移。

当前正在53号柱面执行操作的读写磁头是移动臂由里向外(向0号柱面方向)带到53号柱面的位置，因此，当访问53号柱面的操作结束后，依次访问的次序为37、14，65，67，98，122，124，183。

读写磁头共移动了208个柱面的距离。

(ii)移动臂先向里移。

当前正在53号柱面执行操作的读写磁头是移动臂由外向里(向柱面号增大方向)带到53号柱面的位置，因此，当访问53号柱面的操作结束后，依次访问的次序为65、67，98，122，124，183、37，14柱面的访问者服务。

读写磁头共移动了299个柱面的距离。

(总之象电梯一样，移动一个来回完成所有访问）(4)．单向扫描调度算法方向是从外向里扫描，即从0柱面开始，访问的柱面次序为：65,67,98,122,124,183,14,37 读写磁头一共移动了12+2+31+24+2+59+14+231. 一个磁盘组有100个柱面，每柱面8个磁道，每磁道8个扇区，现有一个文件含5000个记录，每记录与扇区大小相等，在磁盘组上顺序存放（从0面0道0扇区开始），问（1）第3468个记录的物理位置（2）第56个柱面上第7磁道第5扇区对应的块号。

操作系统中的调度算法分析操作系统是计算机系统中最为重要的组成部分之一，它负责管理计算机系统的资源，包括硬件和软件资源，并且为其它应用程序提供支持和服务。

在操作系统中，调度算法是其中非常重要的一部分，对于它的优化和改进有着非常重要的意义。

本文将按照类别对操作系统中的调度算法进行详细分析，包括批处理系统中的调度算法、交互式系统中的调度算法、实时系统中的调度算法，以及多处理器系统中的调度算法。

一、批处理系统中的调度算法批处理系统是指能够自动地运行一批作业的操作系统，它是在没有任何人的干预下完成作业的自动化系统。

在批处理系统中的调度算法，其主要目的是使各作业的吞吐率最大，并且减少响应时间和等待时间。

在批处理系统中的调度算法包括先来先服务（FCFS）算法、短进程优先（SJF）算法、最高响应比优先（HRRN）算法等。

1、先来先服务（FCFS）算法先来先服务算法，也称为先到先服务算法，是最简单的一种调度算法。

它的作用是按照进程的到达时间的先后顺序进行服务，先到达的进程先得到服务，后到达的进程则必须等待前面进程的服务结束才能够被执行。

优点是公平、简单，缺点是会导致长作业等待时间长，短作业等待时间短。

2、短进程优先（SJF）算法短进程优先算法，是按照进程的执行时间长度来排序，执行时间越短的进程优先得到服务，它可以使得等待时间总和最小，从而提高系统的吞吐率。

但是，如果遇到长作业，则会导致短作业等待时间过长。

3、最高响应比优先（HRRN）算法最高响应比优先算法，则是综合考虑前两种算法的优点而得到的一种调度算法，它会计算出每个进程的响应比，并且选择响应比最高的进程进行执行。

响应比的计算公式是：响应比 = (等待时间 + 执行时间) / 执行时间该算法可以最大限度地减少等待时间，并且适用于长作业与短作业的服务。

二、交互式系统中的调度算法相比于批处理系统，交互式系统强调用户体验，需要快速响应用户的指令请求。

因此，交互式系统中的调度算法，其主要目的是降低响应时间，尽可能快地处理用户的请求。

操作系统调度算法1.先来先服务（FCFS）调度算法：先来先服务调度算法是最简单的调度算法之一、按照任务到达的先后顺序进行调度，先来的任务先得到执行，直到完成或阻塞。

该算法不考虑任务的执行时间，可能导致短任务等待时间过长，产生“饥饿”现象。

2.最短作业优先（SJF）调度算法：最短作业优先调度算法在任务到达时根据任务所需执行时间进行排序，选择执行时间最短的任务。

该算法可以最小化平均等待时间和周转时间，但需要完全了解任务的执行时间，对于无法准确预测执行时间的情况效果较差。

3.优先级调度算法：优先级调度算法为每个任务分配一个优先级，按照优先级从高到低进行调度。

常见的优先级调度算法有静态优先级调度和动态优先级调度。

静态优先级调度在任务到达时即确定优先级，而动态优先级调度可以根据任务的实时状态动态调整优先级。

优先级调度算法需要合理设置优先级，避免产生“饥饿”现象。

4.时间片轮转（RR）调度算法：时间片轮转调度算法将CPU时间划分为一个个固定长度的时间片，任务按照顺序分配时间片，如果任务在一个时间片内无法完成，则将其放入就绪队列的末尾，继续执行下一个任务。

时间片轮转调度算法可以降低响应时间和提高交互性，但对于长时间的任务可能会造成不必要的上下文切换。

5.多级反馈队列调度算法：多级反馈队列调度算法将任务分为多个不同优先级的队列，每个队列按照FCFS或RR算法进行调度。

任务在较高优先级队列等待一定时间后，如果未能完成，则降低优先级，放入更低优先级队列继续执行。

多级反馈队列调度算法可以适应不同任务类型和执行时间。

总结来说，不同的调度算法适用于不同的场景和需求。

先来先服务调度算法简单直观，但可能存在任务等待时间过长的问题；最短作业优先调度算法可以最小化任务的平均等待时间和周转时间，但需要准确预测任务的执行时间；优先级调度算法可以根据任务的重要性进行优先级调度，但需要合理设置优先级；时间片轮转调度算法可以提高交互性，但可能造成不必要的上下文切换；多级反馈队列调度算法可以适应不同任务类型和执行时间，但需要合理设置队列的优先级和时间片长度。

2.3.3调度的实现方法一、作业调度功能（一）采用作业控制块（J C B）表格，记录系统中各作业工作状况。

（二）根据选定的调度算法，从后备作业中选出一部分（多道情况）或一个作业投入运行。

（三）为被选中的作业做好运行前的准备，包括选择系统相应的“进程”执行单元以及为这些“进程”分配系统资源，首先判断用户的资源要求是否能够满足。

（四）作业处理后的善后处理工作，例如：回收资源和记帐等工作。

二、调度算法设计的目标（一）系统尽量大的吞吐量。

（二）C P U保持忙。

（三）I/O保持忙。

（四）对所有类型的作业尽量公平。

三、设计调度算法要考虑的主要因素（一）算法应符合系统的总目标。

（二）资源使用均衡，系统效率尽量高。

（三）保证进入系统的作业在规定的时间内完成。

四、常用的作业调度算法（一）先来先服务（f i r s t c o m e f i r s t s e r v e，F C F S）1、作业执行次序与作业进入输入井次序相同。

2、优点（1）实现简单。

（2）对相同的或均衡的作业较为合理。

3、缺点不利于运行时间短的作业。

（二）最短作业优先法（s h o r t e s t j o b f i s t，S J F）1、最短作业优先法也就是选t i值小的优先，也就是只考虑运行时间。

2、优点短作业得到了优先执行，提高了系统的效率。

3、缺点当作业不断进入时，长的作业有可能长时间等待。

（三）最高响应比优先法（h i g h e s t r e s p o n s e-r a t i o n e x t，H R N）1、最高响应比优先法（H R N）是对F C F S方式和S J F方式的一种综合平衡。

H R N调度策略调度时，同时考虑每个作业的等待时间长短和估计需要的执行时间长短，从中选出响应比最高的作业投入执行。

2、响应比或称响应系数比R定义如下：R=（W+T）/T=1+W/T其中T为该作业估计需要的执行时间，W为作业在后备状态队列中的等待时间。

操作系统—移动臂调度算法实现移动臂调度算法是指磁盘调度算法中的一种，主要用于提高磁盘读写操作的效率。

它是在磁盘读写请求队列中选择下一个读写请求的顺序，以减少寻道时间和旋转延迟，从而提高磁盘的响应速度。

常见的移动臂调度算法有FCFS（先来先服务）、SSTF（最短寻道时间优先）、SCAN（电梯算法）、C-SCAN（循环扫描算法）等。

SSTF（Shortest Seek Time First）是选择距离当前磁头最近的磁道进行处理。

它充分考虑了寻道时间，优先处理距离当前位置较近的请求，能够有效减少磁头移动的时间。

SCAN（电梯算法）是按照一个方向上的连续磁道进行处理，当到达一些方向的极限时，改变方向继续处理。

它模拟了电梯上下行的行为，能够有效减少磁头移动的次数，提高磁盘效率。

C-SCAN（循环扫描算法）类似于SCAN算法，不同之处在于当到达一些方向的极限时，不改变方向继续处理，而是返回磁道的起点重新开始。

以下是一个移动臂调度算法的实现：```pythondef FCFS(requests, start):current = startfor request in requests:current = requestdef SSTF(requests, start):current = startwhile requests:next_request = min(requests, key=lambda x: abs(x - current)) current = next_requestrequests.remove(next_request)def SCAN(requests, start, direction):current = startif direction == "up":for i in range(current, max(requests) + 1):if i in requests:current = ielif direction == "down":for i in range(current, min(requests) - 1, -1):if i in requests:current = idef C_SCAN(requests, start, direction):current = startif direction == "up":for i in range(current, max(requests) + 1):if i in requests:current = ielif direction == "down":for i in range(current, min(requests) - 1, -1):if i in requests:current = i#测试样例requests = [98, 183, 37, 122, 14, 124, 65, 67]start = 53direction = "up"print("FCFS: ", FCFS(requests, start))print("SSTF: ", SSTF(requests, start))print("SCAN: ", SCAN(requests, start, direction))print("C-SCAN: ", C_SCAN(requests, start, direction))```以上是一个简单的移动臂调度算法的实现，通过给定的请求队列和起始位置，可以计算出不同调度算法下的总寻道时间。

计算机操作系统调度算法计算机操作系统将任务分成多个进程，并将它们分配给CPU 以便执行。

当多个进程在互相竞争CPU时，调度算法将帮助操作系统决定哪个进程将被运行。

调度算法可以提高系统的性能和响应速度，同时还能减少资源浪费。

1.先进先出（FIFO）调度算法先进先出调度算法是最简单的算法。

该算法按照每个进程进入系统的顺序依次分配CPU时间，并等待该进程完成后再运行下一个进程。

FIFO算法很容易实现，但是它的缺点是没有考虑进程的优先级和执行时间。

这意味着，长时间运行的进程可能会阻塞短时间运行的进程，并且平均等待时间也无法减少。

2.最短作业优先（SJF）调度算法最短作业优先调度算法是一个基于进程执行时间的预测算法。

该算法会优先运行预计执行时间最短的进程，因此平均等待时间会更短。

但该算法有一个问题：如果存在长时间运行的进程，那么它们可能永远无法运行，这会导致一些进程一直处于等待状态。

3.优先级调度算法优先级调度算法通过为每个进程分配不同的优先级，来确定哪个进程应该先运行。

预设的进程优先级可能基于进程的类型、缺陷、执行时间和操作系统要求等因素。

4.时间片轮转（RR）调度算法时间片轮转调度算法是一种基于时间分配CPU时间的算法。

该算法为每个进程分配一个小的时间片，如10ms或50ms，并按照时间片依次运行进程。

如果进程无法在一个时间片内完成，则进程被送到队列的末尾。

时间片轮转调度算法可以避免长时间运行的进程阻塞短时间运行的进程，并提高平均等待时间。

5.多级反馈队列（MFQ）调度算法多级反馈队列调度算法是一种结合了以上几种调度算法的算法。

它将进程分配到几个队列中，每个队列有不同的优先级和时间片。

优先级高，时间片较长的队列中，会先运行高优先级的进程。

如果进程超出了它被分配的时间，并在该队列中一直等待，进程会在等待时间超过设定时间限制后继续移动到更低优先级的队列。

总结不同的任务需要不同的调度算法。

例如，对于短时间运行的进程，SJF算法可能表现最好，而RR算法适用于需要等待时间短的任务。

操作系统作业调度算法在计算机操作系统中，作业调度算法起着至关重要的作用。

它决定了哪些作业能够被优先处理，以及如何合理地分配系统资源，以提高整个系统的性能和效率。

让我们先来理解一下什么是作业调度。

简单来说，当有多个作业等待被处理时，操作系统需要决定哪个作业先进入处理状态，哪个作业需要等待。

这就像是在一个繁忙的餐厅，服务员需要决定先为哪桌客人上菜一样。

常见的作业调度算法有先来先服务（FCFS）、短作业优先（SJF）、优先级调度、高响应比优先调度和时间片轮转调度等。

先来先服务算法是最简单直观的一种。

它按照作业到达的先后顺序进行调度。

就好比排队买票，先到的人先买。

这种算法的优点是实现简单、公平，大家都按照先来后到的顺序。

但它也有明显的缺点，如果先到达的作业执行时间很长，后面的短作业就需要长时间等待，可能会导致系统的平均周转时间较长。

短作业优先算法则是优先处理执行时间短的作业。

这就像是在餐厅中，先为点了简单菜品的客人上菜。

它的优点是能够减少平均周转时间，提高系统的吞吐量。

但问题是，我们很难准确预知作业的执行时间，而且如果一直有更短的作业到来，长作业可能会被“饿死”。

优先级调度算法为每个作业赋予一个优先级，优先级高的作业先被处理。

这有点像医院的急诊室，病情紧急的患者优先得到治疗。

这种算法可以灵活地根据作业的重要性或紧急程度来安排处理顺序，但确定合理的优先级可能会比较困难，而且如果优先级设置不当，也可能导致一些作业长时间得不到处理。

高响应比优先调度算法综合考虑了作业的等待时间和执行时间。

响应比＝（等待时间＋执行时间）／执行时间。

这样既照顾了先来的作业，又不会让短作业等待太久。

它在一定程度上克服了先来先服务和短作业优先算法的缺点，但计算响应比也会增加系统的开销。

时间片轮转调度算法将 CPU 时间分成固定大小的时间片，每个作业轮流使用一个时间片。

如果作业在一个时间片内没有完成，就会被放到队列的末尾等待下一轮。

这就像是大家轮流发言，每人都有一定的时间。

磁盘移臂调度算法
磁盘移臂调度算法是操作系统中磁盘调度算法的一种，其作用是为了提高磁盘读写效率。

磁盘移臂调度算法的思想是尽可能地减少磁盘移臂的次数，从而提高磁盘读写效率和系统响应速度。

下面就来介绍几种比较常见的磁盘移臂调度算法。

首先是先来先服务（FCFS）算法，具体的实现方式是按照磁盘请求的顺序进行处理，先来的请求先得到服务，但是这种算法容易产生“饥饿”状态，即某些请求长时间等待得不到服务的情况。

其次是最短寻道时间优先（SSTF）算法，该算法会优先选择磁头距离当前要访问的磁道最近的那个请求进行处理，简单高效但可能导致跨度大的请求一直被忽略。

再次是扫描（SCAN）算法，它的思路是磁头按照同一方向移动，直到抵达磁盘末端，然后自动返回到另一端并继续处理其他请求，不过SCAN算法可能会造成磁盘最中心区域的请求得不到服务。

最后是循环扫描（C-SCAN）算法，它的思想是磁头在磁盘上发生扫描操作，从而按照一条直线进行磁盘的处理，当遇到磁盘末尾时立即回到磁盘起始端口，且只在往该方向转移时服务请求，可以有效地平衡请求响应时间。

总体来说，磁盘移臂调度算法在提高磁盘读写效率方面起到了重要作用。

通过优化调度算法，可以使得磁盘访问时间更加快速，也能更好地实现磁盘系统的稳定性。

南京工程学院上机实验报告课程名称：操作系统实验项目名称：移动臂调度算法的实现学生班级：学生学号：学生姓名：指导教师：实验时间：实验地点：信息楼专业机房实验成绩评定：2016-2017-1学期一、实验目的及内容掌握操作系统的设备管理功能，熟悉移动臂调度算法，设计恰当的数据结构和算法，模拟实现移动臂调度算法。

要求至少模拟实现一种磁盘移臂调度算法。

二、实验相关知识简介磁盘移臂调度的目标就是要使磁盘访问的总时间中的寻找时间最小。

因此，磁盘移臂调度要尽量减少磁盘移动臂移动的距离。

磁盘移臂调度算法很多，常用的也有好几种，一个好的磁盘调度算法，不仅要使磁盘寻找时间最小，同时，还要避免移动臂频繁地改变移动方向，因为频繁的改向不仅使时间增加，还容易损耗机械部件。

常用的磁盘移臂调度算法有：先来先服务、最短寻找时间优先、单向扫描、双向扫描调度算法等。

三、解决问题思路及关键程序代码分析(一) 最短寻找时间优先调度算法简介最短寻找时间调度算法总是使寻找时间最短的请求最先得到服务，跟请求者的请求时间先后顺序无关。

这种算法具有比先来先服务更好的性能。

但是该算法可能会出现请求者被“饿死”的情况，当靠近磁头的请求源源不断地到来，这会使早来的但离磁头较远的请求长时间得不到服务。

该算法的优点是可以得到较短的平均响应时间，有较好的吞吐量。

该算法的缺点是缺乏公平性，对中间磁道的访问比较“照顾”，对两端磁道访问比较“疏远”，相应时间的变化幅度较大。

该算法与先来先服务算法一样，都会导致移动臂频繁改向。

(二) 算法模拟1. 对算法设计进行说明该算法的实现中，主要是选择调度处理的磁道是与当前磁头所在磁道距离最近的磁道，以使每次的寻道时间最短。

当选择了某个离当前磁头所在磁道最近的磁道，下一轮的当前磁道便改成了上一轮的最近磁道，并且把这个最近的磁道从请求序列取消，直到请求序列中不再有请求的磁道。

2. 关键代码分析import java.io.*;import java.util.*;public class{private static int maxsize = 100;private static int Disc[] = new int[maxsize]; //请求序列private static int count;//要访问的磁道数private static int disc; //当前磁道号private static int perTime;//移过每个柱面需要时间private static int Distance=0;//总寻道长度private static int FindTime;//查找时间private static double AvgDistance;//平均寻道长度public Suanfa(int disc,int count,int perTime,int Disc[]){this.disc=disc;this.count=count;this.perTime=perTime;for(int i=0;i<Disc.length;i++)Disc[i]=Disc[i];}public void input(){System.out.print("请输入当前磁道号:");Scanner s1=new Scanner(System.in);disc=s1.nextInt();System.out.print("请输入要访问的磁道数:");Scanner s2=new Scanner(System.in);count=s2.nextInt();System.out.print("请输入移过每个柱面需要的时间:");Scanner s3=new Scanner(System.in);perTime=s3.nextInt();System.out.print("请输入磁盘请求序列（以空格隔开）:");Scanner s4=new Scanner(System.in);for(int i=0;i<count;i++)Disc[i]=s4.nextInt();}public void Delete(int arr[],int n){for(int i=n;i<arr.length-1;i++)arr[i]=arr[i+1];}public void running(){int j=0,count1=count;int min;int discc=disc;int Discc[]=new int[count];while(j<count){int num=0;min=(Disc[0]>=discc)?(Disc[0]-discc):(discc-Disc[0]);for(int i=0;i<count1;i++){if(((Disc[i]>=discc)&&(Disc[i]-discc<min))||((Disc[i]<discc)&&(discc-Disc[i ]<min))){min=(Disc[i]>=discc)?(Disc[i]-discc):(discc-Disc[i]);num=i;}}Discc[j++]=Disc[num];Distance+=min;discc=Disc[num];Delete(Disc,num);count1--;}AvgDistance=(double)Distance/count;FindTime=perTime*Distance;System.out.print("\n服务序列:"+disc+" ");for(int i=0;i<count;i++)System.out.print(Discc[i]+" ");System.out.println("\n总寻道长度:"+Distance);System.out.println("平均寻道长度:"+AvgDistance);System.out.println("寻道时间:"+FindTime+"ms");}public static void main(String[] args){System.out.println("----------最短寻找时间优先算法----------");Suanfa Suanfa=new Suanfa(disc,count,perTime,Disc);Suanfa.input();Suanfa.running();}}四、运行结果程序的运行结果如图所示：五、体会与提高通过本次的实验设计，把教材中的理论知识转化为实践，在一定程度上深了我对读者-写者这类经典的同步问题的理解，同时也提高了我的动手编程和独立思考的能力。

操作系统实验报告处理机调度算法的实现*名：***学号： ********班级：09计算机1一、实验名称及要求1、实验名称：处理机调度算法的实现2、实验要求：了解操作系统处理机调度概念的基本概念，处理机调度程序的功能，常用的处理机调度算法。

C或C++编程方法与语句格式，提前初步编好试验程序。

3、实验方式：通过实验室的微机上机，实际调试程序。

4、实验环境：Windows操作系统环境下的个人微机Ｃ或Ｃ＋＋程序设计语言二、实验内容１．设定系统中有五个进程，每一个进程用一个进程控制块表示。

２．输入每个进程的“优先数”和“要求运行时间”。

３．为了调度方便，将五个进程按给定的优先数从大到小连成就绪队列。

用一单元指出队列进程，用指针指出队列的链接情况。

４．处理机调度总是选队首进程运行。

采用动态优先数算法，进程每运行一次优先数就减“１”，同时将运行时间减“１”。

５．若要求运行时间为零，则将其状态置为“结束”，且对出队列。

６．运行所设计进程，显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。

三、实验程序#include <stdio.h>#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0struct pcb /* 定义进程控制块PCB */{char name[20];char state;int super;int ntime;int rtime;struct pcb* link;} *ready=NULL,*p;typedef struct pcb PCB;void sort() /* 建立对进程进行优先级排列函数*/{PCB *first, *second;int insert=0;if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/ {p->link=ready;ready=p;}else /* 进程比较优先级,插入适当的位置中*/{first=ready;second=first->link;while(second!=NULL){if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/{ /*插入到当前进程前面*/p->link=second;first->link=p;second=NULL;insert=1;}else /* 插入进程优先数最低,则插入到队尾*/ {first=first->link;second=second->link;}}if(insert==0) first->link=p;}}void input() /* 建立进程控制块函数*/{int i,num;printf("\n 请输入进程数: ");scanf("%d",&num);for(i=1;i<=num;i++){printf("\n 进程号:No.%d\n",i);p=getpch(PCB);printf("\n 请输入进程名:");scanf("%s",p->name);printf("\n 请输入进程的优先数:");scanf("%d",&p->super);printf("\n 请输入进程的运行时间:");scanf("%d",&p->ntime);printf("\n");p->rtime=0;p->state='W';p->link=NULL;sort(); /* 调用sort函数*/}}int space(){int l=0;PCB* pr=ready;while(pr!=NULL){l++;pr=pr->link;}return(l);}void disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/{printf("\n 进程名\t 进程状态\t 优先数\t 需要运行时间\t 已经运行时间\n");printf("|%s\t",pr->name);printf("|%c\t",pr->state);printf("|%d\t",pr->super);printf("|%d\t\t",pr->ntime);printf("|%d\t",pr->rtime);printf("\n");}void check() /* 建立进程查看函数 */{PCB* pr;printf("\n **** 当前正在运行的进程是:\n"); /*显示当前运行进程*/disp(p);pr=ready;printf("\n **** 当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL){disp(pr);pr=pr->link;}}void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/ {printf("\n 进程 [%s] 已完成.\n",p->name);free(p);}void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/ {(p->rtime)++;if(p->rtime==p->ntime)destroy(); /* 调用destroy函数*/else{(p->super)--;p->state='W';sort(); /*调用sort函数*/}}void main() /*主函数*/{int len,h=0;char ch;input();len=space();while((len!=0)&&(ready!=NULL)){ch=getchar();h++;printf("-----------------------------------------------------");printf("\n 现在是第%d次运行： \n",h);p=ready;ready=p->link;p->link=NULL;p->state='R';check();running();printf("\n 按回车键继续......\n");}printf("\n\n 进程已经完成.\n");}四、实验结果五．实验总结进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。

实验二调度算法的模拟实现一、实验目的1.加深对先来先服务算法，短作业优先算法，最高优先权优先调度算法等三种调度算法的理解2.利用C语言编写算法，模拟实现先来先服务算法，短作业优先算法，最高优先权优先调度算法。

3.模拟三种调度算法，对比三种调度算法的优缺点，并计算平均周转时间和平均带权周转时间。

二、实验开发平台Microsoft Visual C++ 6.0（使用C语言）三、三个调度算法说明先来先服务调度算法，是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度，就是每次从就绪队列中选择一个最先进入队列的进程，该算法比较有利于长作业，而不利于短作业。

另处，FCFS调度算法对CPU繁忙型作业较有利，而不利于I/O繁忙作业。

短作业优先调度算法（SWF），是指对短作业或短进程优先调度的算法，是指分派CPU时，把CPU优先分给最短的作业。

它的缺点是对长作业不利，不能保证及时处理解紧迫性的作业。

最高优先权优先调度算法，常用于批处理系统中，既照顾了短作业，又考虑了作业到达的先后次序，不会使长作业长期得不到服务。

它实现了一种较好的折衷,但每要进行高度之前，都须先做响应比的计算，这会增加系统开销。

四、实验源程序#include <stdio.h>struct process{char name[10];int dtime;int ftime;int youxian;};struct process pro[3];struct process tempPro[3];void fcfs()//先来先服务{//先对这些线程排序,使用冒泡法排序，从小到大int i,j;for (i=0;i<3-1;i++){for (j=0;j<2-i;j++){if (pro[j].dtime>pro[j+1].dtime){tempPro[j]=pro[j];pro[j]=pro[j+1];pro[j+1]=tempPro[j];}}}}void sjf()//短作业优先{//使用冒泡法排序,从小到大int i,j;for (i=0;i<3-1;i++){for (j=0;j<2-i;j++){if (pro[j].ftime>pro[j+1].ftime){tempPro[j]=pro[j];pro[j]=pro[j+1];pro[j+1]=tempPro[j];}}}}void youxian()//最高优先权优先，假定此处为优先数最大的进程优先服务{ //使用冒泡法排序，从大到小int i,j;for (i=0;i<3-1;i++){for (j=0;j<2-i;j++){if (pro[j].youxian<pro[j+1].youxian){tempPro[j]=pro[j];pro[j]=pro[j+1];pro[j+1]=tempPro[j];}}}}void print()//输出进程名称{int i;for (i=0;i<3;i++){printf("%s\n",pro[i].name);}}void main(){printf("请输入第一个进程的名字到达时间服务时间优先数\n");scanf("%s %3d %3d %3d",&pro[0].name,&pro[0].dtime,&pro[0].ftime,&pro[0].youxian);printf("请输入第二个进程的名字到达时间服务时间优先数\n");scanf("%s %3d %3d %3d",&pro[1].name,&pro[1].dtime,&pro[1].ftime,&pro[1].youxian);printf("请输入第三个进程的名字到达时间服务时间优先数\n");scanf("%s %3d %3d %3d",&pro[2].name,&pro[2].dtime,&pro[2].ftime,&pro[2].youxian);printf("先来先服务调度执行顺序：\n");fcfs();print();printf("短作业优先调度执行顺序：\n");sjf();print();printf("最高优先权优先调度执行顺序：\n");youxian();print();}五、运行结果。