精华内容
参与话题
问答
  • 调度算法

    2020-09-29 09:04:17
    前言 最近,我偷偷潜伏在各大技术群,因为秋招在即,看到不少小伙伴分享的大厂面经。...进程调度算法也称 CPU 调度算法,毕竟进程是由 CPU 调度的。 当 CPU 空闲时,操作系统就选择内存中的某个「就绪.

    前言

    最近,我偷偷潜伏在各大技术群,因为秋招在即,看到不少小伙伴分享的大厂面经。

    然后发现,操作系统的知识点考察还是比较多的,大厂就是大厂就爱问基础知识。其中,关于操作系统的「调度算法」考察也算比较频繁。

    所以,我这边总结了操作系统的三大调度机制,分别是「进程调度/页面置换/磁盘调度算法」,供大家复习,希望大家在秋招能斩获自己心意的 offer。

     


    正文

    进程调度算法

    进程调度算法也称 CPU 调度算法,毕竟进程是由 CPU 调度的。

    当 CPU 空闲时,操作系统就选择内存中的某个「就绪状态」的进程,并给其分配 CPU。

    什么时候会发生 CPU 调度呢?通常有以下情况:

    1. 当进程从运行状态转到等待状态;

    2. 当进程从运行状态转到就绪状态;

    3. 当进程从等待状态转到就绪状态;

    4. 当进程从运行状态转到终止状态;

    其中发生在 1 和 4 两种情况下的调度称为「非抢占式调度」,2 和 3 两种情况下发生的调度称为「抢占式调度」。

    非抢占式的意思就是,当进程正在运行时,它就会一直运行,直到该进程完成或发生某个事件而被阻塞时,才会把 CPU 让给其他进程。

    而抢占式调度,顾名思义就是进程正在运行的时,可以被打断,使其把 CPU 让给其他进程。那抢占的原则一般有三种,分别是时间片原则、优先权原则、短作业优先原则。

    你可能会好奇为什么第 3 种情况也会发生 CPU 调度呢?假设有一个进程是处于等待状态的,但是它的优先级比较高,如果该进程等待的事件发生了,它就会转到就绪状态,一旦它转到就绪状态,如果我们的调度算法是以优先级来进行调度的,那么它就会立马抢占正在运行的进程,所以这个时候就会发生 CPU 调度。

    那第 2 种状态通常是时间片到的情况,因为时间片到了就会发生中断,于是就会抢占正在运行的进程,从而占用 CPU。

    调度算法影响的是等待时间(进程在就绪队列中等待调度的时间总和),而不能影响进程真在使用 CPU 的时间和 I/O 时间。

    接下来,说说常见的调度算法:

    • 先来先服务调度算法

    • 最短作业优先调度算法

    • 高响应比优先调度算法

    • 时间片轮转调度算法

    • 最高优先级调度算法

    • 多级反馈队列调度算法

    先来先服务调度算法

    最简单的一个调度算法,就是非抢占式的先来先服务(First Come First Severd, FCFS)算法了。

    FCFS 调度算法

    顾名思义,先来后到,每次从就绪队列选择最先进入队列的进程,然后一直运行,直到进程退出或被阻塞,才会继续从队列中选择第一个进程接着运行。

    这似乎很公平,但是当一个长作业先运行了,那么后面的短作业等待的时间就会很长,不利于短作业。

    FCFS 对长作业有利,适用于 CPU 繁忙型作业的系统,而不适用于 I/O 繁忙型作业的系统。

    最短作业优先调度算法

    最短作业优先(Shortest Job First, SJF)调度算法同样也是顾名思义,它会优先选择运行时间最短的进程来运行,这有助于提高系统的吞吐量。

    SJF 调度算法

    这显然对长作业不利,很容易造成一种极端现象。

    比如,一个长作业在就绪队列等待运行,而这个就绪队列有非常多的短作业,那么就会使得长作业不断的往后推,周转时间变长,致使长作业长期不会被运行。

    高响应比优先调度算法

    前面的「先来先服务调度算法」和「最短作业优先调度算法」都没有很好的权衡短作业和长作业。

    那么,高响应比优先 (Highest Response Ratio Next, HRRN)调度算法主要是权衡了短作业和长作业。

    每次进行进程调度时,先计算「响应比优先级」,然后把「响应比优先级」最高的进程投入运行,「响应比优先级」的计算公式:

    从上面的公式,可以发现:

    • 如果两个进程的「等待时间」相同时,「要求的服务时间」越短,「响应比」就越高,这样短作业的进程容易被选中运行;

    • 如果两个进程「要求的服务时间」相同时,「等待时间」越长,「响应比」就越高,这就兼顾到了长作业进程,因为进程的响应比可以随时间等待的增加而提高,当其等待时间足够长时,其响应比便可以升到很高,从而获得运行的机会;

    时间片轮转调度算法

    最古老、最简单、最公平且使用最广的算法就是时间片轮转(Round Robin, RR)调度算法

    RR 调度算法

    每个进程被分配一个时间段,称为时间片(Quantum),即允许该进程在该时间段中运行。

    • 如果时间片用完,进程还在运行,那么将会把此进程从 CPU 释放出来,并把 CPU 分配另外一个进程;

    • 如果该进程在时间片结束前阻塞或结束,则 CPU 立即进行切换;

    另外,时间片的长度就是一个很关键的点:

    • 如果时间片设得太短会导致过多的进程上下文切换,降低了 CPU 效率;

    • 如果设得太长又可能引起对短作业进程的响应时间变长;

    通常时间片设为 20ms~50ms 通常是一个比较合理的折中值。

    最高优先级调度算法

    前面的「时间片轮转算法」做了个假设,即让所有的进程同等重要,也不偏袒谁,大家的运行时间都一样。

    但是,对于多用户计算机系统就有不同的看法了,它们希望调度是有优先级的,即希望调度程序能从就绪队列中选择最高优先级的进程进行运行,这称为最高优先级(Highest Priority First,HPF)调度算法

    进程的优先级可以分为,静态优先级或动态优先级:

    • 静态优先级:创建进程时候,就已经确定了优先级了,然后整个运行时间优先级都不会变化;

    • 动态优先级:根据进程的动态变化调整优先级,比如如果进程运行时间增加,则降低其优先级,如果进程等待时间(就绪队列的等待时间)增加,则升高其优先级,也就是随着时间的推移增加等待进程的优先级

    该算法也有两种处理优先级高的方法,非抢占式和抢占式:

    • 非抢占式:当就绪队列中出现优先级高的进程,运行完当前进程,再选择优先级高的进程。

    • 抢占式:当就绪队列中出现优先级高的进程,当前进程挂起,调度优先级高的进程运行。

    但是依然有缺点,可能会导致低优先级的进程永远不会运行。

    多级反馈队列调度算法

    多级反馈队列(Multilevel Feedback Queue)调度算法是「时间片轮转算法」和「最高优先级算法」的综合和发展。

    顾名思义:

    • 「多级」表示有多个队列,每个队列优先级从高到低,同时优先级越高时间片越短。

    • 「反馈」表示如果有新的进程加入优先级高的队列时,立刻停止当前正在运行的进程,转而去运行优先级高的队列;

     

    多级反馈队列

    来看看,它是如何工作的:

    • 设置了多个队列,赋予每个队列不同的优先级,每个队列优先级从高到低,同时优先级越高时间片越短

    • 新的进程会被放入到第一级队列的末尾,按先来先服务的原则排队等待被调度,如果在第一级队列规定的时间片没运行完成,则将其转入到第二级队列的末尾,以此类推,直至完成;

    • 当较高优先级的队列为空,才调度较低优先级的队列中的进程运行。如果进程运行时,有新进程进入较高优先级的队列,则停止当前运行的进程并将其移入到原队列末尾,接着让较高优先级的进程运行;

    可以发现,对于短作业可能可以在第一级队列很快被处理完。对于长作业,如果在第一级队列处理不完,可以移入下次队列等待被执行,虽然等待的时间变长了,但是运行时间也会更长了,所以该算法很好的兼顾了长短作业,同时有较好的响应时间。


    内存页面置换算法

    在了解内存页面置换算法前,我们得先谈一下缺页异常(缺页中断)

    当 CPU 访问的页面不在物理内存时,便会产生一个缺页中断,请求操作系统将所缺页调入到物理内存。那它与一般中断的主要区别在于:

    • 缺页中断在指令执行「期间」产生和处理中断信号,而一般中断在一条指令执行「完成」后检查和处理中断信号。

    • 缺页中断返回到该指令的开始重新执行「该指令」,而一般中断返回回到该指令的「下一个指令」执行。

    我们来看一下缺页中断的处理流程,如下图:

    缺页中断的处理流程
     

    1. 在 CPU 里访问一条 Load M 指令,然后 CPU 会去找 M 所对应的页表项。

    2. 如果该页表项的状态位是「有效的」,那 CPU 就可以直接去访问物理内存了,如果状态位是「无效的」,则 CPU 则会发送缺页中断请求。

    3. 操作系统收到了缺页中断,则会执行缺页中断处理函数,先会查找该页面在磁盘中的页面的位置。

    4. 找到磁盘中对应的页面后,需要把该页面换入到物理内存中,但是在换入前,需要在物理内存中找空闲页,如果找到空闲页,就把页面换入到物理内存中。

    5. 页面从磁盘换入到物理内存完成后,则把页表项中的状态位修改为「有效的」。

    6. 最后,CPU 重新执行导致缺页异常的指令。

    上面所说的过程,第 4 步是能在物理内存找到空闲页的情况,那如果找不到呢?

    找不到空闲页的话,就说明此时内存已满了,这时候,就需要「页面置换算法」选择一个物理页,如果该物理页有被修改过(脏页),则把它换出到磁盘,然后把该被置换出去的页表项的状态改成「无效的」,最后把正在访问的页面装入到这个物理页中。

    这里提一下,页表项通常有如下图的字段:

    那其中:

    • 状态位:用于表示该页是否有效,也就是说是否在物理内存中,供程序访问时参考。

    • 访问字段:用于记录该页在一段时间被访问的次数,供页面置换算法选择出页面时参考。

    • 修改位:表示该页在调入内存后是否有被修改过,由于内存中的每一页都在磁盘上保留一份副本,因此,如果没有修改,在置换该页时就不需要将该页写回到磁盘上,以减少系统的开销;如果已经被修改,则将该页重写到磁盘上,以保证磁盘中所保留的始终是最新的副本。

    • 硬盘地址:用于指出该页在硬盘上的地址,通常是物理块号,供调入该页时使用。

    这里我整理了虚拟内存的管理整个流程,你可以从下面这张图看到:

    虚拟内存的流程

    所以,页面置换算法的功能是,当出现缺页异常,需调入新页面而内存已满时,选择被置换的物理页面,也就是说选择一个物理页面换出到磁盘,然后把需要访问的页面换入到物理页。

    那其算法目标则是,尽可能减少页面的换入换出的次数,常见的页面置换算法有如下几种:

    • 最佳页面置换算法(OPT

    • 先进先出置换算法(FIFO

    • 最近最久未使用的置换算法(LRU

    • 时钟页面置换算法(Lock

    • 最不常用置换算法(LFU

    最佳页面置换算法

    最佳页面置换算法基本思路是,置换在「未来」最长时间不访问的页面

    所以,该算法实现需要计算内存中每个逻辑页面的「下一次」访问时间,然后比较,选择未来最长时间不访问的页面。

    我们举个例子,假设一开始有 3 个空闲的物理页,然后有请求的页面序列,那它的置换过程如下图:

    最佳页面置换算法

    在这个请求的页面序列中,缺页共发生了 7 次(空闲页换入 3 次 + 最优页面置换 4 次),页面置换共发生了 4 次。

    这很理想,但是实际系统中无法实现,因为程序访问页面时是动态的,我们是无法预知每个页面在「下一次」访问前的等待时间。

    所以,最佳页面置换算法作用是为了衡量你的算法的效率,你的算法效率越接近该算法的效率,那么说明你的算法是高效的。

    先进先出置换算法

    既然我们无法预知页面在下一次访问前所需的等待时间,那我们可以选择在内存驻留时间很长的页面进行中置换,这个就是「先进先出置换」算法的思想。

    还是以前面的请求的页面序列作为例子,假设使用先进先出置换算法,则过程如下图:

    先进先出置换算法

    在这个请求的页面序列中,缺页共发生了 10 次,页面置换共发生了 7 次,跟最佳页面置换算法比较起来,性能明显差了很多。

    最近最久未使用的置换算法

    最近最久未使用(LRU)的置换算法的基本思路是,发生缺页时,选择最长时间没有被访问的页面进行置换,也就是说,该算法假设已经很久没有使用的页面很有可能在未来较长的一段时间内仍然不会被使用。

    这种算法近似最优置换算法,最优置换算法是通过「未来」的使用情况来推测要淘汰的页面,而 LRU 则是通过「历史」的使用情况来推测要淘汰的页面。

    还是以前面的请求的页面序列作为例子,假设使用最近最久未使用的置换算法,则过程如下图:

    最近最久未使用的置换算法

    在这个请求的页面序列中,缺页共发生了 9 次,页面置换共发生了 6 次,跟先进先出置换算法比较起来,性能提高了一些。

    虽然 LRU 在理论上是可以实现的,但代价很高。为了完全实现 LRU,需要在内存中维护一个所有页面的链表,最近最多使用的页面在表头,最近最少使用的页面在表尾。

    困难的是,在每次访问内存时都必须要更新「整个链表」。在链表中找到一个页面,删除它,然后把它移动到表头是一个非常费时的操作。

    所以,LRU 虽然看上去不错,但是由于开销比较大,实际应用中比较少使用。

    时钟页面置换算法

    那有没有一种即能优化置换的次数,也能方便实现的算法呢?

    时钟页面置换算法就可以两者兼得,它跟 LRU 近似,又是对 FIFO 的一种改进。

    该算法的思路是,把所有的页面都保存在一个类似钟面的「环形链表」中,一个表针指向最老的页面。

    当发生缺页中断时,算法首先检查表针指向的页面:

    • 如果它的访问位位是 0 就淘汰该页面,并把新的页面插入这个位置,然后把表针前移一个位置;

    • 如果访问位是 1 就清除访问位,并把表针前移一个位置,重复这个过程直到找到了一个访问位为 0 的页面为止;

    我画了一副时钟页面置换算法的工作流程图,你可以在下方看到:

    时钟页面置换算法

    了解了这个算法的工作方式,就明白为什么它被称为时钟(Clock)算法了。

    最不常用算法

    最不常用(LFU)算法,这名字听起来很调皮,但是它的意思不是指这个算法不常用,而是当发生缺页中断时,选择「访问次数」最少的那个页面,并将其淘汰

    它的实现方式是,对每个页面设置一个「访问计数器」,每当一个页面被访问时,该页面的访问计数器就累加 1。在发生缺页中断时,淘汰计数器值最小的那个页面。

    看起来很简单,每个页面加一个计数器就可以实现了,但是在操作系统中实现的时候,我们需要考虑效率和硬件成本的。

    要增加一个计数器来实现,这个硬件成本是比较高的,另外如果要对这个计数器查找哪个页面访问次数最小,查找链表本身,如果链表长度很大,是非常耗时的,效率不高。

    但还有个问题,LFU 算法只考虑了频率问题,没考虑时间的问题,比如有些页面在过去时间里访问的频率很高,但是现在已经没有访问了,而当前频繁访问的页面由于没有这些页面访问的次数高,在发生缺页中断时,就会可能会误伤当前刚开始频繁访问,但访问次数还不高的页面。

    那这个问题的解决的办法还是有的,可以定期减少访问的次数,比如当发生时间中断时,把过去时间访问的页面的访问次数除以 2,也就说,随着时间的流失,以前的高访问次数的页面会慢慢减少,相当于加大了被置换的概率。


    磁盘调度算法

    我们来看看磁盘的结构,如下图:

    磁盘的结构

    常见的机械磁盘是上图左边的样子,中间圆的部分是磁盘的盘片,一般会有多个盘片,每个盘面都有自己的磁头。右边的图就是一个盘片的结构,盘片中的每一层分为多个磁道,每个磁道分多个扇区,每个扇区是 512 字节。那么,多个具有相同编号的磁道形成一个圆柱,称之为磁盘的柱面,如上图里中间的样子。

    磁盘调度算法的目的很简单,就是为了提高磁盘的访问性能,一般是通过优化磁盘的访问请求顺序来做到的。

    寻道的时间是磁盘访问最耗时的部分,如果请求顺序优化的得当,必然可以节省一些不必要的寻道时间,从而提高磁盘的访问性能。

    假设有下面一个请求序列,每个数字代表磁道的位置:

    98,183,37,122,14,124,65,67

    初始磁头当前的位置是在第 53 磁道。

    接下来,分别对以上的序列,作为每个调度算法的例子,那常见的磁盘调度算法有:

    • 先来先服务算法

    • 最短寻道时间优先算法

    • 扫描算法算法

    • 循环扫描算法

    • LOOK 与 C-LOOK 算法

    先来先服务

    先来先服务(First-Come,First-Served,FCFS),顾名思义,先到来的请求,先被服务。

    那按照这个序列的话:

    98,183,37,122,14,124,65,67

    那么,磁盘的写入顺序是从左到右,如下图:

    先来先服务

    先来先服务算法总共移动了 640 个磁道的距离,这么一看这种算法,比较简单粗暴,但是如果大量进程竞争使用磁盘,请求访问的磁道可能会很分散,那先来先服务算法在性能上就会显得很差,因为寻道时间过长。

    最短寻道时间优先

    最短寻道时间优先(Shortest Seek First,SSF)算法的工作方式是,优先选择从当前磁头位置所需寻道时间最短的请求,还是以这个序列为例子:

    98,183,37,122,14,124,65,67

    那么,那么根据距离磁头( 53 位置)最近的请求的算法,具体的请求则会是下列从左到右的顺序:

    65,67,37,14,98,122,124,183

    最短寻道时间优先

    磁头移动的总距离是 236 磁道,相比先来先服务性能提高了不少。

    但这个算法可能存在某些请求的饥饿,因为本次例子我们是静态的序列,看不出问题,假设是一个动态的请求,如果后续来的请求都是小于 183 磁道的,那么 183 磁道可能永远不会被响应,于是就产生了饥饿现象,这里产生饥饿的原因是磁头在一小块区域来回移动

    扫描算法

    最短寻道时间优先算法会产生饥饿的原因在于:磁头有可能再一个小区域内来回得移动。

    为了防止这个问题,可以规定:磁头在一个方向上移动,访问所有未完成的请求,直到磁头到达该方向上的最后的磁道,才调换方向,这就是扫描(Scan)算法

    这种算法也叫做电梯算法,比如电梯保持按一个方向移动,直到在那个方向上没有请求为止,然后改变方向。

    还是以这个序列为例子,磁头的初始位置是 53:

    98,183,37,122,14,124,65,67

    那么,假设扫描调度算先朝磁道号减少的方向移动,具体请求则会是下列从左到右的顺序:

    37,14,0,65,67,98,122,124,183

    扫描算法

    磁头先响应左边的请求,直到到达最左端( 0 磁道)后,才开始反向移动,响应右边的请求。

    扫描调度算法性能较好,不会产生饥饿现象,但是存在这样的问题,中间部分的磁道会比较占便宜,中间部分相比其他部分响应的频率会比较多,也就是说每个磁道的响应频率存在差异。

    循环扫描算法

    扫描算法使得每个磁道响应的频率存在差异,那么要优化这个问题的话,可以总是按相同的方向进行扫描,使得每个磁道的响应频率基本一致。

    循环扫描(Circular Scan, CSCAN )规定:只有磁头朝某个特定方向移动时,才处理磁道访问请求,而返回时直接快速移动至最靠边缘的磁道,也就是复位磁头,这个过程是很快的,并且返回中途不处理任何请求,该算法的特点,就是磁道只响应一个方向上的请求

    还是以这个序列为例子,磁头的初始位置是 53:

    98,183,37,122,14,124,65,67

    那么,假设循环扫描调度算先朝磁道增加的方向移动,具体请求会是下列从左到右的顺序:

    65,67,98,122,124,183,1990,14,37

    循环扫描算法

    磁头先响应了右边的请求,直到碰到了最右端的磁道 199,就立即回到磁盘的开始处(磁道 0),但这个返回的途中是不响应任何请求的,直到到达最开始的磁道后,才继续顺序响应右边的请求。

    循环扫描算法相比于扫描算法,对于各个位置磁道响应频率相对比较平均。

    LOOK 与 C-LOOK算法

    我们前面说到的扫描算法和循环扫描算法,都是磁头移动到磁盘「最始端或最末端」才开始调换方向。

    那这其实是可以优化的,优化的思路就是磁头在移动到「最远的请求」位置,然后立即反向移动。

    那针对 SCAN 算法的优化则叫 LOOK 算法,它的工作方式,磁头在每个方向上仅仅移动到最远的请求位置,然后立即反向移动,而不需要移动到磁盘的最始端或最末端,反向移动的途中会响应请求

    LOOK 算法

    而针 C-SCAN 算法的优化则叫 C-LOOK,它的工作方式,磁头在每个方向上仅仅移动到最远的请求位置,然后立即反向移动,而不需要移动到磁盘的最始端或最末端,反向移动的途中不会响应请求

    C-LOOK 算法

    展开全文
  • 优先级调度算法3.多级反馈队列调度算法4.三种算法的对比总结 0.思维导图 1.时间片轮转—RR Round-Robin 时间片为2举例 以时间片为5举例 可能出现的问题,比如与FCFS对比 2.优先级调度算法 非抢占式例子 -...


    0.思维导图

    在这里插入图片描述

    1.时间片轮转—RR

    • Round-Robin
      在这里插入图片描述
    • 时间片为2举例
      在这里插入图片描述在这里插入图片描述
    • 以时间片为5举例
      在这里插入图片描述
    • 可能出现的问题,比如与FCFS对比
      在这里插入图片描述
      在这里插入图片描述

    2.优先级调度算法

    在这里插入图片描述

    • 非抢占式例子
      在这里插入图片描述- 抢占式例子

    在这里插入图片描述

    • 补充
      在这里插入图片描述

    3.多级反馈队列调度算法

    在这里插入图片描述
    在这里插入图片描述

    • 举个例子
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述

    4.三种算法的对比总结

    在这里插入图片描述

    展开全文
  • 调度算法—SJF调度算法详解

    千次阅读 2020-06-12 21:44:26
    详述我自身理解的SJF算法实现的思路,先按到达时间排序,再比较服务时间,附完整代码。

    吐槽

    上课时操作系统没咋学,倒不是不想学,实在是老师讲的太乏味,照着PPT读,今天学习SJF时,发现不少博客写错了,居然直接将服务时间排序而不考虑到达时间,导致我一下陷入自我怀疑。

    SJF概念介绍

    SJF,全称Short Job First,中文名:短作业优先调度算法
    优点:考虑到作业的服务时间情况,降低了周转时间等相应时间;
    缺点:有可能短进程一致插队,导致长进程处于长期饥饿状态;
    理解误区:不是直接将进程按服务时间的长短排序后顺序执行!!,而是先按到达时间排序,若有多个进程的到达时间小于上一进程的结束时间,则将这多个进程按服务时间长短调度

    SJF代码实现

    CreateProcessQueue模块的实现思路和之前我写的先来先服务算法FCFS的CreateProcessQueue模块的实现思路一样,实现创建进程和初始化进程功能。

    Sort模块的实现思路:

    • 冒泡算法

    SJF模块的实现思路:

    1. 先将所有进程按到达时间排序,用sort函数实现;
    2. 利用循环体依次调度进程;
    3. 判断进程状态,‘f’为未调用;
    4. 先实现第一个进程;
    5. 往后的进程判断到达时间是否小于上一进程的结束时间;
    6. 若小于上一进程的结束时间,将小于上一进程结束时间的进程按服务时间排序,这里利用冒泡算法;
    7. 若大于,直接执行;

    这里使用了数组存取进程,是因为SJF算法很少涉及插入删除操作,比较链表,还是数组更合适。

    SJF算法的完整实现代码:

    #include<stdio.h>
    #include<stdlib.h>
    #define MAX 100
    
    typedef struct PCB{
    	int no;
    	char name[10];
    	char State;
    	int ArrivalTime;            //到达时间 
    	int ServeTime;              //服务时间 
    	int StartTime;              //开始时间 
    	int EndTime;                //结束时间 
    	float TurnaroundTime;       //周转时间 
    	float TakePowerTime;        //带权周转时间 
    	struct PCB *next;
    }PCB;
    
    PCB Queue[MAX] = {0};
    int time;                       //计时器 
    int n;							//进程数量 
    
    void CreateProcessQueue(){
    	printf("创建进程数:");
    	scanf("%d",&n);
    	for(int i=0;i<n;i++){
    		//进程初始化 
    		Queue[i].State = 'f';           
    		Queue[i].StartTime = 0;
    		Queue[i].EndTime = 0;
    		Queue[i].TakePowerTime = 0;
    		Queue[i].TurnaroundTime = 0;
    		printf("进程编号 进程名 到达时间 服务时间\n");
    		scanf("%d %s %d %d",&Queue[i].no,&Queue[i].name,&Queue[i].ArrivalTime,&Queue[i].ServeTime);		
    	}
    }
    
    void Run(PCB pcb){
    	pcb.State = 't';
    	pcb.StartTime = time;
    	pcb.EndTime = pcb.ServeTime+pcb.StartTime;
    	time = pcb.EndTime;
    	pcb.TurnaroundTime = pcb.EndTime - pcb.ArrivalTime;
    	pcb.TakePowerTime = pcb.TurnaroundTime/pcb.ServeTime;
    	printf("进程编号 进程名 开始时间 结束时间 周转时间 带权周转时间\n");
    	printf("%d       %s     %d        %d       %.2f     %.2f\n",pcb.no,pcb.name,pcb.StartTime,pcb.EndTime,pcb.TurnaroundTime,pcb.TakePowerTime);
    }
    
    void sort(){
    	//按到达时间排序 
    	for(int j=0;j<n;j++){
    		for(int i=0;i<n-j-1;i++){
    			if(Queue[i].ArrivalTime>Queue[i+1].ArrivalTime){
    				PCB temp = Queue[i];
    				Queue[i] = Queue[i+1];
    				Queue[i+1] = temp;
    			}	
    		}
    	}
    }
    
    void SJF(){
    	sort();
    	time = Queue[0].ArrivalTime;
    
    	for(int i=0;i<n;i++){
    		if(Queue[i].State = 'f'){
    			if(i ==0){
    				Run(Queue[i]);	
    			}else if(Queue[i].ArrivalTime<time){
    				int num = i;
    				while(Queue[num].ArrivalTime<time && num<n){
    					num++;
    				}
    				for(int x=i;x<num;x++){
    					for(int t=i;t<num-x;t++){
    						if(Queue[t].ServeTime>Queue[t+1].ServeTime){
    							PCB temp = Queue[t];
    							Queue[t] = Queue[t+1];
    							Queue[t+1] = temp;
    						}	
    					}
    				}
    				Run(Queue[i]);
    			}else{
    				Run(Queue[i]);
    			}				
    		}
    	}
    }
    
    int  main(){
    	CreateProcessQueue();
    	SJF();
    	return 0;
    }  
    

    一些思考

    我实现SJF算法时走了很多弯路,集中在SJF模块,我之前曾想若多个进程小于计时器时间,通过排序找到最小服务时间进程并执行,但这样就漏掉了最小服务时间进程前面的进程,因为循环体不会往前走。也曾想通过一些限制返回到漏掉的进程处重新开始,但没能实现。

    之所以能用冒泡算法将小于计时器的进程排序,因为之后的进程必然在这些进程中选择执行,因为之前是按到达时间排序的。

    展开全文
  • FCFS实现磁盘调度算法

    2020-06-03 09:29:17
    FCFS算法根据进程请求访问磁盘的先后顺序进行调度,这是一种最简单的调度算法。该算法的优点是具有公平性。如果只有少量进程需要访问,且大部分请求都是访问簇聚的文件扇区,则有望达到较好的性能;但如果有大量进程...
  • 调度算法—FCFS调度算法详解

    千次阅读 2020-06-11 18:45:17
    详解我自身理解的FCFS算法的实现思路,附代码

    FCFS概念介绍

    FCFS,全称First come First Serve,中文名:先来先调度算法。
    优点:简单,易实现;
    缺点:对短作业不公平;

    FCFS代码实现

    FCFS算法的实现步骤:
    1.确定进程块的变量
    2.创建进程队列,可以用链表等等
    3.依次计算每个进程并删除,输出

    CreateProcessQueue模块实现思路:

    • 利用循环体,创建进程并初始化;
    • 利用链表,将每个进程相关联;
    • 分情况,按有头节点和没头节点讨论,要注意每个进程的存储空间用p指针指向,所以p的值在每次循环中都会改变,不能用来指向下一个元素位置,这里用q来当游标;

    FCFS模块实现思路:

    • 利用循环体和if判断,确定进程是否被调度,未被调度则状态为‘f’,调用run模块调度;

    run模块实现思路:

    • 将状态改为‘t’,表示已调度,这里我进行了修改,进程调度完就删掉;
    • 计算周转时间,带权周转时间;

    FCFS完整调度算法代码:

    #include<stdio.h>
    #include<stdlib.h>
    #include<cstring>
    //进程控制块,数据结构 —结构体 
    typedef struct PCB{
    	char PcbName[10];
    	int PcbNo;
    	char State;
    	int ArrivalTime;
    	int StartTime;
    	int ServeTime;
    	int EndTime;
    	int TurnaroundTime;
    	float TakePowerTime;
    	struct PCB *next;
    }PCB;
    
    PCB *head = NULL,*q,*p;           //头节点 
    int time;				   //计时器 
    int n;                     //进程数
    
    //创建进程队列,采用链表结构
    void CreateProcessQueue(){
    	printf("创建进程数:\n");
    	scanf("%d",&n);
    	for(int i=0;i<n;i++){
    		p=(PCB *)malloc(sizeof(PCB));
    		p->StartTime = 0;
    		p->EndTime = 0;
    		p->TurnaroundTime = 0;
    		p->TakePowerTime = 0;
    		p->State = 'f'; 
    		p->ArrivalTime = 0;
    		printf("进程编号 进程名 到达时间 服务时间\n");
    		scanf("%d %s %d %d",&p->PcbNo,&p->PcbName,&p->ArrivalTime,&p->ServeTime);
            if(head==NULL)
            {
                head=p;q=p;time=p->ArrivalTime;
            }else{
            	q->next=p;
            	p->next=NULL;
            	q=p;
    		}
    	}
    } 
    
    void run(PCB *temp){
    	temp->State = 't';
    	time = temp->ArrivalTime>time?temp->ArrivalTime:time;
    	temp->StartTime = time;
    	temp->EndTime = temp->ServeTime+temp->StartTime;
    	time = temp->EndTime; 
    	temp->TurnaroundTime = temp->EndTime-temp->ArrivalTime;
    	temp->TakePowerTime = temp->TurnaroundTime/temp->ServeTime;
    	printf("进程编号 进程名 开始时间 结束时间 周转时间 带权周转时间\n");
    	printf("%d       %s     %d       %d       %d        %d\n",temp->PcbNo,temp->PcbName,temp->StartTime,temp->EndTime,temp->TurnaroundTime,temp->TakePowerTime);
    	p = temp->next;
    }
    
    //First Come First Serve
    void FCFS(){
    	p = head;
    	for(int i=0;i<n;i++){
    		if(p->State == 'f'){
    			run(p);
    		}
    	}
    }
    
    int main(){
    	CreateProcessQueue();
    	FCFS();
    	return 0;
    } 
    
    
    

    在这里插入图片描述

    展开全文
  • 时间片轮转调度算法、优先级调度算法、多级反馈队列调度算法 1.先了解下算法的评估 cpu 利用率 = 忙碌时间 / 总时间 系统吞吐量 = 总共完成多少道作业 / 总共花了多少时间 周转时间 周转时间:(作业提交到 操作系统...
  • 实时操作系统:优先级调度算法 非抢占式 抢占式优先级调度算法:新进程来的时候判断一下是不是要抢占只有第1级队列所以的运行完了才会把CPU给第2级队列,P2在第二级队列运行到1个时间片后 P3到达第1级队列,此时P2就...
  • 文章目录一、先来先服务(FCFS)调度算法二、最短作业优先(SJF)算法1. 非抢占式SJF2. 抢占式SJF三、优先级调度算法1. 非抢占式优先级调度算法2. 抢占式优先级调度算法四、时间片轮转(RR)算法五、多级队列调度 一...
  • 通过对实时系统中静态调度算法RM和动态调度算法EDF的研究与分析,针对两种调度算法在实际应用中的问题,提出了一种基于阈值δ的混合调度算法,将RM与EDF调度算法相结合,并从数学角度描述了混合调度算法的可调度性与...
  •  掌握进程调度算法,如先来先服务调度算法(first come first served,FCFS)、短作业优先调度算法(shotjob first,SJF)、时间片轮转调度算法。 二、 实验内容设计模拟实现FCFS、SJF、时间片轮转调度算法的C语言...
  • 轮转调度算法(RR): 主要用于分时系统 按先来先服务原则进行调度,但有时间片,当时间片用完时,进程无论是否完成,就会切换下一个进程,而未完成的进程则会排队到末尾等待其他进程时间片用完后再被调度。 特点:...
  • 抢占式
  • 编程实现两种处理机调度算法,可选择的以下组合方式其中之- -: 1) 高优先级优先调度算法和时间片轮转调度算法; 2) 短进程优先调度算法和时间片轮转调度算法; 3) 先入先出调度算法和时间片轮转让调度算法。 选择-一...
  • <!-- @Author: starkwang @Contact me: ... @Date: 2019-10-23 17:05:02 @LastEditors: starkwang @LastEditTime: 2019-10-23 17:12:46 @Description: nginx的 upstream模块调度算法调度算法 -...

空空如也

1 2 3 4 5 ... 20
收藏数 16,509
精华内容 6,603
关键字:

调度算法