精华内容
下载资源
问答
  • 磁盘调度算法的实现
    千次阅读
    2019-12-25 17:49:59
    def loaddata(fileName):     # 读取数据
        f = open(fileName)
        start = f.readline()    # 读入data文件的第一行作为起始磁道
        data = f.readline()     # 依次读入数据作为下一个被访问的磁道号
        return start, data
    
    
    def loadnext(now, next):    # 输出下一个被访问的磁道号和移动距离
        length = abs(int(now) - int(next))  # 移动距离
        str_length =str(length)
        if len(next) == 3:
            if len(str_length) == 1:
                print("|         ", end="")
                print(next, end="")
                print("         |   ", end="")
                print("    ", end="")
                print(length, end="")
                print("        |")
            elif len(str_length) == 2:
                print("|         ", end="")
                print(next, end="")
                print("         |   ", end="")
                print("    ", end="")
                print(length, end="")
                print("       |")
            else:
                print("|         ", end="")
                print(next, end="")
                print("         |   ", end="")
                print("    ", end="")
                print(length, end="")
                print("      |")
        elif len(next) == 2:
            if len(str_length) == 1:
                print("|          ", end="")
                print(next, end="")
                print("         |   ", end="")
                print("    ", end="")
                print(length, end="")
                print("        |")
            elif len(str_length) == 2:
                print("|          ", end="")
                print(next, end="")
                print("         |   ", end="")
                print("    ", end="")
                print(length, end="")
                print("       |")
            else:
                print("|          ", end="")
                print(next, end="")
                print("         |   ", end="")
                print("    ", end="")
                print(length, end="")
                print("      |")
        elif len(next) == 1:
            if len(str_length) == 1:
                print("|           ", end="")
                print(next, end="")
                print("         |   ", end="")
                print("    ", end="")
                print(length, end="")
                print("        |")
            elif len(str_length) == 2:
                print("|           ", end="")
                print(next, end="")
                print("         |   ", end="")
                print("    ", end="")
                print(length, end="")
                print("       |")
            else:
                print("|           ", end="")
                print(next, end="")
                print("         |   ", end="")
                print("    ", end="")
                print(length, end="")
                print("      |")
        return length
    
    
    def FCFS():
        l = 0
        start, data = loaddata('data')
        print("|--------------------------------------|")
        print("|  被访问的下一个磁道号  |     移动距离     |")
        print("|--------------------------------------|")
        for d in data.split():
            l += loadnext(start, d)     # 循环输出下一个磁道号和移动距离,并将寻道距离累加
            start = d                   # 将刚访问的磁道作为下次访问的起始磁道
        n = len(data.split())
        print("|--------------------------------------|")
        print("| 先来先服务(FCFS)的平均寻道长度:%.1f      |" % (l / n))
        print("|--------------------------------------|")
    
    
    def findnextindex(start, datas):    # SSTF算法
        length = []
        for data in datas:
            l = abs(int(start) - int(data))     # 计算磁道间要移动的距离
            length.append(l)                    # 计算的将每个距离放入距离数组
        minIndex = length.index(min(length))    # 在数组中选出最小的距离在数组中位置
        return minIndex
    
    
    def SSTF():
        l = 0
        start, data = loaddata('data')
        data2 = data.split().copy()
        n = len(data2)
        print("|--------------------------------------|")
        print("|  被访问的下一个磁道号  |     移动距离     |")
        print("|--------------------------------------|")
        for d in data.split():
            nextIndex = findnextindex(start, data2)     # 获取每次的最小寻道距离
            l += loadnext(start, data2[nextIndex])
            start = data2[nextIndex]
            data2.remove(data2[nextIndex])
    
        print("|--------------------------------------|")
        print("|最短寻道时间优先(SSTF)的平均寻道长度:%.1f  |" % (l / n))
        print("|--------------------------------------|")
    
    
    def findnext1(now, data):                   # SCAN
        biggerList = []
        smallerList = []
        for d in data:
            if int(d) > int(now):               # 判断初始磁道和下一磁道的大小关系
                biggerList.append(d)            # 如果下一磁道号更大则将其放入大数组中
        if (len(biggerList) == 0):              # 否则则开始寻找比初始磁道小的磁道号
            if len(data) != 0:
                for d2 in data:
                    if int(d2) < int(now):
                        smallerList.append(d2)  # 将其加入小数组中
                return max(smallerList)
            else:
                return None
        return min(biggerList)
    
    
    def SCAN():
        l = 0
        start, data = loaddata('data')
        data2 = data.split().copy()
        print("|--------------------------------------|")
        print("|  被访问的下一个磁道号  |     移动距离     |")
        print("|--------------------------------------|")
        n = len(data2)
        for d in data:
            next = findnext1(start, data2)         #
            if next == None:
                break
            l += loadnext(start, next)
            start = next
            data2.remove(next)
        print("|--------------------------------------|")
        print("|电梯调度算法(SCAN)平均寻道长度:%.1f       |" % (l / n))
        print("|--------------------------------------|")
    
    
    def findnext2(now, data):               # CSCAN
        biggerList = []
        smallerList = []
        for d in data:
            if int(d) > int(now):
                biggerList.append(d)
        if (len(biggerList) == 0):
            if len(data) != 0:
                now = 0
                return (findnext2(now, data))
            else:
                return None
        return min(biggerList)
    
    
    def CSCAN():
        l = 0
        start, data = loaddata('data')
        data2 = data.split().copy()
        n = len(data2)
        print("|--------------------------------------|")
        print("|  被访问的下一个磁道号  |     移动距离     |")
        print("|--------------------------------------|")
        for d in data:
            next = findnext2(start, data2)
            if next == None:
                break
            l += loadnext(start, next)
            start = next
            data2.remove(next)
        print("|--------------------------------------|")
        print("|循环扫描算法(CSCAN)平均寻道长度:%.1f      |" % (l / n))
        print("|--------------------------------------|")
    
    
    def main():
        num4 = int(input("恢复原磁道(1、是;0、否):"))
        if num4 == 1:
            filename = 'data'
            with open(filename, 'w') as f:
                first = "100"
                second = "55 58 39 18 90 160 150 38 184"
                f.write(first)
                f.write("\n")
                f.write(second)
        else:
            print("")
        start, data = loaddata('data')
        print("|------------磁盘调度算法程序-------------|")
        print("|------1、先来先服务      (FCFS )算法-----|")
        print("|------2、最短寻道时间优先 (SSTF )算法-----|")
        print("|------3、电梯调度        (SCAN )算法-----|")
        print("|------4、循环扫描算法     (CSCAN)算法-----|")
        print("|---------------------------------------|")
        print("初始磁道为:" + start + data)
        num = int(input("请选择要使用的调度算法(1~4):"))
        if num == 1:
            FCFS()
        elif num == 2:
            SSTF()
        elif num == 3:
            SCAN()
        elif num == 4:
            CSCAN()
        else:
            num1 = int(input("您没有做出选择,是否需要指定访问的磁道?(1:是 0:否)"))
            if num1 == 1:
                # 100
                # 55 58 39 18 90 160 150 38 184
                print("原磁道顺序为:100 \n"+"55 58 39 18 90 160 150 38 184")
                filename = 'data'
                with open(filename, 'w') as f:
                    first = int(input("请输入初始访问磁道:"))
                    second = input("请输入被访问的下一个磁道号序列(用空格分开):")
                    f.write(str(first))
                    f.write("\n")
                    f.write(str(second))
    
            else:
                num3 = int(input("是否选择关闭程序?(1:是 0:否)"))
                if num3 == 1 :
                    print("程序结束!谢谢使用。")
                    exit()
                elif num3 == 0:
                    main()
                else:
                    print("选择错误!")
                    main()
        num2 = int(input("是否继续选择?(1:是 0:否,关闭程序)"))
        if num2 == 1:
            main()
        elif num2 == 0:
            print("程序结束!谢谢使用。")
            exit()
        else:
            print("选择错误!")
            main()
    
    
    if __name__ == "__main__":
        main()
    
    更多相关内容
  • (1) 实现磁盘调度算法有FCFS,SSTF,SCAN,CSCAN和 NStepSCAN算法。 (2) 设定开始磁道号寻道范围,依据起始扫描磁道号和最大磁道号数,随机产生要进行寻道的磁道号序列。 (3) 选择磁盘调度算法,显示该算法的磁道...
  • 操作系统实验三磁盘调度算法实现
  • 个人资料整理 仅限学习使用 实验七磁盘调度算法 目 录 一实验目的 加深对磁盘的工作原理和调度效率的理解掌握各种磁盘调度算法模拟实现一种磁盘调度算法 等 b5E2RGbCAP 二实验属性 该实验为设计性实验 个人资料整理 ...
  • 1.了解UNIX的命令及使用格式,熟悉UNIX/LINUX...2.设计一个磁盘工作区,并使用先来先服务算法(FCFS)、最短寻道时间优先算法(SSTF)、扫描算法(SCAN)和循环扫描算法(C-SCAN)计算磁头移动的总磁道数。 平均磁道数
  • 磁盘调度
  • 武汉理工大学计算机科学与技术学院操作系统磁盘调度算法
  • 如何使用代码: ... 磁盘调度算法 磁盘调度是由操作系统完成的,以调度到达磁盘的I / O请求。 磁盘调度也称为I / O调度。 磁盘调度很重要,因为: Multiple I/O requests may arrive by different processe
  • 磁盘调度算法实现

    2019-01-05 22:28:05
     Java编程实现模拟FCFS、SSTF、SCAN的磁盘调度程序, ui界面。该程序设计系统首面输入磁道序列,主面可以选择某种算法并算出磁头移动的总磁道数以及平均磁道数。并且在面板上显示计算算信息
  • 操作系统磁盘调度算法实验报告
  • 磁盘调度算法 学生姓名: 学生学号: 专业班级: 指导老师 2013 年6月20日 1实验目的 通过这次实验加深对磁盘调度算法的理解进一步掌握先来先 服务 FCFS最短寻道时间优先 SSTFSCAN和循环 SCAN算法的实现 方法 2问题描述...
  • NULL 博文链接:https://bosshida.iteye.com/blog/620814
  • 假设有 n 个磁道号所组成 的磁道访问序列,给定开始磁道号 m 和磁头移动的方向,正向 或者反向,分别利用不同的磁盘调度算法访问磁道序列,给出 每一次访问的磁头移动距离,计算每种算法的平均寻道长度
  • 此程序模拟磁盘调度算法电梯算法和最短寻道时间优先SSTF算法,电梯算法具体实现原理看图片和程序开头的介绍。采用C++语言开发,运用链表,指针实现访问。
  • 该程序包含了四种不同的磁盘调度算法(FCFS,SSTF,SCAN,CSCAN),拥有简单的图形界面。而且在运行四种算法后会显示平均磁道长度,将四种算法的平均磁道长度以柱状图比较直观的形式输出,方便用户进行比较。
  • FIFO:先进先出的调度策略,这个策略具有公平的优点,因为每个请求都会得到处理,并且是按照接收到的顺序进行处理 ...  磁盘调度算法的数据比较  磁盘调度算法的描述  磁盘调度算法的直观比较
  • 磁盘调度算法实验报告(20210919121020).pdf
  • 磁盘调度算法java实现

    热门讨论 2013-05-30 20:54:38
    随机生成磁盘序列 用java实现了FIFO、SSTF、SCAN和C-SCAN算法模拟磁盘调度 有用户界面,有序列结果记录,有计算移动磁道数
  • 基于c++开发的操作系统磁盘调度算法,下载在vc/vs环境中可以直接运行,有较为详细的备注
  • 磁盘调度设计,磁盘调度算法实现,包括  先来先服务调度算法  最短寻道优先调度算法  扫描算法  循环扫描算法  N—Step—SCAN算法
  • FCFS实现磁盘调度算法

    2020-06-03 09:29:17
    FCFS算法根据进程请求访问磁盘的先后顺序进行调度,这是一种最简单的调度算法。该算法的优点是具有公平性。如果只有少量进程需要访问,且大部分请求都是访问簇聚的...所以,实际磁盘调度中考虑一些更为复杂的调度算法
  • 题目二 磁盘调度算法的模拟实现及对比 一、课程设计目的 通过磁盘调度算法的模拟设计,了解磁盘调度的特点。 二、课程设计内容 模拟实现FCFS、SSTF、电梯LOOK、C-SCAN 算法,并计算及比较磁头移动道数。 三、要求及...
  • 磁盘调度算法

    千次阅读 2022-03-31 11:09:32
    磁盘调度算法

    img

    1 一次磁盘读/写操作需要的时间

    **寻找时间(寻道时间)**Ts:在读/写数据前,需要将磁头移动到指定磁道所花费的时间。
    寻道时间分两步:

    (1) 启动磁头臂消耗的时间:s。
    (2) 移动磁头消耗的时间:假设磁头匀速移动,每跨越一个磁道消耗时间为m,共跨越n条磁道。

    则寻道时间 Ts = s + m * n。

    磁头移动到指定的磁道,但是不一定正好在所需要读/写的扇区,所以需要通过磁盘旋转使磁头定位到目标扇区。

    img

    延迟时间TR:通过旋转磁盘,使磁头定位到目标扇区所需要的时间。设磁盘转速为r(单位:转/秒,或转/分),则平均所需延迟时间TR = (1/2)*(1/r) = 1/2r。

    1/r就是转一圈所需的时间。找到目标扇区平均需要转半圈,因此再乘以1/2。

    传输时间TR:从磁盘读出或向磁盘中写入数据所经历的时间,假设磁盘转速为r,此次读/写的字节数为b,每个磁道上的字节数为N,则传输时间TR = (b/N) * (1/r) = b/(rN)。

    每个磁道可存N字节数据,因此b字节数据需要b/N个磁道才能存储。而读/写一个磁道所需的时间刚好是转一圈的时间1/r。

    总的平均时间Ta = Ts + 1/2r + b/(rN),由于延迟时间和传输时间都是与磁盘转速有关的,且是线性相关。而转速又是磁盘的固有属性,因此无法通过操作系统优化延迟时间和传输时间。所以只能优化寻找时间。

    2 磁盘调度算法

    2.1 先来先服务算法(FCFS)

    算法思想:根据进程请求访问磁盘的先后顺序进行调度。
    假设磁头的初始位置是100号磁道,有多个进程先后陆续地请求访问55、58、39、18、90、160、150、38、184号磁道。
    按照先来先服务算法规则,按照请求到达的顺序,磁头需要一次移动到55、58、39、18、90、160、150、38、184号磁道。

    img

    磁头共移动了 45 + 3 + 19 + 21 + 72 + 70 + 10 + 112 + 146 = 498个磁道。响应一个请求平均需要移动498 / 9 = 55.3个磁道(平均寻找长度)。
    优点:公平;如果请求访问的磁道比较集中的话,算法性能还算可以
    缺点:如果大量进程竞争使用磁盘,请求访问的磁道很分散,FCFS在性能上很差,寻道时间长

    2.2 最短寻找时间优先(SSTF)

    算法思想:优先处理的磁道是与当前磁头最近的磁道。可以保证每次寻道时间最短,但是不能保证总的寻道时间最短。(其实是贪心算法的思想,只是选择眼前最优,但是总体未必最优)。

    假设磁头的初始位置是100号磁道,有多个进程先后陆续地请求访问55、58、39、18、90、160、150、38、184号磁道。

    img

    磁头总共移动了(100 -18)+ (184 -18) = 248个磁道。响应一个请求平均需要移动248 / 9 = 27.5个磁道(平均寻找长度)。
    缺点:可能产生饥饿现象
    本例中,如果在处理18号磁道的访问请求时又来了一个38号磁道的访问请求,处理38号磁道的访问请求又来了一个18号磁道访问请求。如果有源源不断的18号、38号磁道访问请求,那么150、160、184号磁道请求的访问就永远得不到满足,从而产生饥饿现象。这里产生饥饿的原因是磁头在一小块区域来回移动。

    2.3 扫描算法(SCAN)

    电梯算法(LOOK算法)。(扫到最大请求柱面)

    假设某磁盘的磁道为0~200号,磁头的初始位置是100号磁道,且此时磁头正在往磁道号增大的方向移动,有多个进程先后陆续的访问55、58、39、18、90、160、150、38、184号磁道。

    img

    磁头共移动了(184 - 100)+ (184 -18) = 250个磁道。响应一个请求平均需要移动 250 / 9 = 27.5个磁道(平均寻找长度)。

    扫描算法(一扫到底,然后依次扫回来去)

    循环扫描算法

    循环扫描(C-SCAN)调度是 SCAN 的一个变种,以提供更均匀的等待时间。像 SCAN 一样,C-SCAN 移动磁头从磁盘一端到磁盘另一端,并且处理行程上的请求。然而,当磁头到达另一端时,它立即返回到磁盘的开头,而并不处理任何回程上的请求。(一扫到底,然后迅速回到首柱面,再依次往后扫

    C-SCAN磁盘调度

    请求。(一扫到底,然后迅速回到首柱面,再依次往后扫

    [外链图片转存中…(img-t59NNeKq-1648696162725)]

    展开全文
  • java实现磁盘调度算法(操作系统)

    1.随机生成一个访问磁道顺序

    import java.util.HashMap;
    import java.util.Map;
    import java.util.Random;
    
    public class Course {
        private Map<Integer,Integer> map;
        int quantity;
    
        public int getQuantity() {
            return quantity;
        }
    
        public Course() {
            map=new HashMap<>();
            quantity=(new Random().nextInt(20))+1;//数量
            for (int i = 0; i < quantity; i++) {
                int n=new Random().nextInt(100);//磁道数
                if(map.containsValue(n)){
                    i--;
                }else{
                    map.put(i,n);
                }
            }
        }
    
        public Map<Integer, Integer> getMap() {
            return map;
        }
    }
    

    2.实现

    import java.util.HashMap;
    import java.util.Map;
    import java.util.Random;
    import java.util.Scanner;
    
    public class Manage {
        private static int location;
        private static int choose=1;
        private static Map<Integer,Integer> map;
        private static int quantity;
    
        public static void main(String[] args) {
            location = new Random().nextInt(100);
            Course course = new Course();
            while (choose != 5) {
                map=new HashMap<>();
                for (Map.Entry<Integer,Integer> entry:course.getMap().entrySet()) {
                    int key=entry.getKey();
                    int value=entry.getValue();
                    map.put(key,value);
                }
                System.out.println(map);
                System.out.println("磁盘调度算法选择");
                System.out.println("请选择内存分配策略:1.先来先服务算法 2.最短寻道时间优先算法 3.扫描算法 4.循环扫描算法 5.退出(请输入一个数字1~4)");
                Scanner scanner = new Scanner(System.in);
                choose = scanner.nextInt();
                int distance=0;
                int now_location=location;
                quantity=course.getQuantity();
                if(choose==1){
                    for (int i = 0; i <quantity; i++) {
                        int value= map.get(i);
                        System.out.print("目前正在"+now_location+"道 ");
                        distance+=Math.abs(now_location-value);
                        now_location=value;
                    }
                    System.out.print("目前正在"+now_location+"道 ");
                    System.out.println("\n"+"寻道长度为"+distance);
                    map.clear();
                }else if(choose==2){
                    for (int i = 0; i < quantity; i++) {
                        int min=200;
                        int key=0;
                        int value;
                        for (Map.Entry<Integer,Integer> entry:map.entrySet()) {
                            int x=Math.abs(entry.getValue()-now_location);
                            if(x<min){
                                min=x;
                                key=entry.getKey();
                            }
                        }
                        System.out.print("目前正在"+now_location+"道 ");
                        value= map.get(key);
                        distance+=Math.abs(now_location-value);
                        now_location=value;
                        map.remove(key);
                    }
                    System.out.print("目前正在"+now_location+"道 ");
                    System.out.println("\n"+"寻道长度为"+distance);
                }else if(choose==3){
                    int flag=0;//1为正数,2为负数
                    for (int i = 0; i < quantity; i++) {
                        int min=200;
                        int key=-1;
                        int value;
                        int x;
                        int y;
                        for (Map.Entry<Integer,Integer> entry:map.entrySet()) {
                            x = entry.getValue() - now_location;
                            y = Math.abs(x);
                            if(flag==0) {
                                if (y < min) {
                                    min = y;
                                    key = entry.getKey();
                                }
                            }else if(flag==1&&x>0){
                                if (y < min) {
                                    min = y;
                                    key = entry.getKey();
                                }
                            }else if(flag==2&&x<0){
                                if (y < min) {
                                    min = y;
                                    key = entry.getKey();
                                }
                            }
                        }
                        if(key!=-1){
                        if((map.get(key)-now_location)>0){
                            flag=1;
                        }else {
                            flag=2;
                        }
                        }else{
                            flag=flag==1?2:1;
                            i--;
                            continue;
                        }
                        System.out.print("目前正在"+now_location+"道 ");
                        value= map.get(key);
                        distance+=Math.abs(now_location-value);
                        now_location=value;
                        map.remove(key);
                    }
                    System.out.print("目前正在"+now_location+"道 ");
                    System.out.println("\n"+"寻道长度为"+distance);
                }else if(choose==4){
                    //规定磁头道数单向由小到大移动
                    for (int i = 0; i < quantity; i++) {
                        int min=200;
                        int key=-1;
                        int value;
                        int x;
                        int y;
                        for (Map.Entry<Integer,Integer> entry:map.entrySet()) {
                            x = entry.getValue() - now_location;
                            y = Math.abs(x);
                            if(x>0) {
                                if (y < min) {
                                    min = y;
                                    key = entry.getKey();
                                }
                            }
                        }
                        if(key==-1){
                            distance+=(99+99-now_location);
                            now_location=0;
                            i--;
                            continue;
                        }
                        System.out.print("目前正在"+now_location+"道 ");
                        value= map.get(key);
                        distance+=Math.abs(now_location-value);
                        now_location=value;
                        map.remove(key);
                    }
                    System.out.print("目前正在"+now_location+"道 ");
                    System.out.println("\n"+"寻道长度为"+distance);
                }else{
                    continue;
                }
            }
            System.out.println("退出");
        }
    }
    
    展开全文
  • 磁盘调度算法的模拟实现.docx
  • 磁盘调度算法的模拟实现

    千次阅读 2020-07-11 16:01:02
    实现思路: 这是一种最简单但也是效率最低的磁盘调度算法,通过依次读取要访问的磁盘序号即可实现。 void FCFS(int*seq, int start) { int mov = 0;//移动的总磁道数 int temp;//当前磁头的位置 cout << "-...

    1、先来先服务法(FCFS)
    实现思路: 这是一种最简单但也是效率最低的磁盘调度算法,通过依次读取要访问的磁盘序号即可实现。

    void FCFS(int*seq, int start)
    {
        int mov = 0;//移动的总磁道数
        int temp;//当前磁头的位置
        cout << "------FCFS------" << endl;
        cout << "磁头移动的轨迹:" << endl;
        temp = start;
        for(int i=0;i<seq_sum;i++)
        {
            cout << temp << ' ';
                mov+= abs(seq[i] - temp);
            temp = seq[i];
        }
        cout << temp << endl;
        cout << "磁头移动的总磁道数:" << mov << endl;
    }
    

    2、最短寻道时间优先法(SSTF)
    实现思路: 先对要访问的磁盘序列按磁盘序号升序的方式进行排序,其次每次访问与当前磁头的相对位置最小的磁盘,直至序列访问完毕。
    实现举例:
    在这里插入图片描述

    void SSTF(int*seq, int start)
    {
        int min;//当前序号最小的磁道
        int left;//往左的第一个位置
        int right;//往右的第一个位置
        int location;//磁道序列中不大于开始磁道的位置
        int temp;
        int mov = 0;//移动的总磁道数
        int check_seq[10];//为了复制请求访问的磁道序列
        for (int i = 0; i < seq_sum; i++)//复制请求访问的磁道序列
            check_seq[i] = seq[i];
        for (int i = 0; i < seq_sum; i++)//对请求访问的磁道序列按升序进行排序
        {
            min = check_seq[i];
            for (int j = i; j < seq_sum; j++)
            {
                if (check_seq[j] < min)
                {
                    temp = min;
                    min = check_seq[j];
                    check_seq[j] = temp;
                }
            }
            check_seq[i] = min;
        }
        location = -1;
        for (int i = 0; i < seq_sum; i++)//查找start在该序列中的位置
        {
            if (check_seq[i] > start)
                break;
            location++;
        }
        temp = start;
        left = location;
        right= location + 1;
        cout << "------SSTF------" << endl;
        cout << "磁头移动的轨迹:" << endl;
        while (left >= 0 && right < seq_sum)//左边或右边寻道完毕
        {
            if (abs(temp - check_seq[left]) <= abs(temp - check_seq[right]))
            {
                mov += abs(temp - check_seq[left]);
                cout << temp << ' ';
                temp = check_seq[left];
                left--;
            }
            else
            {
                mov += abs(temp - check_seq[right]);
                cout << temp << ' ';
                temp = check_seq[right];
                right++;
            }
        }
        while (left >=0)//一直左寻
        {
            mov += abs(temp - check_seq[left]);
            cout << temp << ' ';
            temp = check_seq[left];
            left--;
        }
        while (right < seq_sum)//一直右寻
        {
            mov += abs(temp - check_seq[right]);
            cout << temp << ' ';
            temp = check_seq[right];
            right++;
        }
        cout <<temp<< endl;
        cout << "磁头移动的总磁道数:" << mov << endl;
    }
    

    3、电梯法(扫描法)
    实现思路: 先对要访问的磁盘序列按磁盘序号升序进行排序,其次只需一次找寻与开始磁头的相对位置最小的磁盘,然后,一直往该方向访问需要访问的磁盘,直至访问完毕。接着,访问另一方向要访问的磁盘,直至访问完毕。
    实现举例:
    在这里插入图片描述
    特点: 与最短寻道时间优先算法的实现基本一样,但它解决了磁头回溯的问题,即只需在刚开始时,一次判断要访问的是哪个磁盘(判断初始的访问方向),接着往该方向依次访问所需访问的磁盘。

    void ElEV(int*seq, int start)
    {
        int min;//当前序号最小的磁道
        int location;//磁道序列中不大于开始磁道的位置
        int temp;
        int mov = 0;//移动的总磁道数
        int check_seq[10];//为了复制请求访问的磁道序列
        for (int i = 0; i < seq_sum; i++)//复制请求访问的磁道序列
            check_seq[i] = seq[i];
        for (int i = 0; i < seq_sum; i++)//对请求访问的磁道序列按升序进行排序
        {
            min = check_seq[i];
            for (int j = i; j < seq_sum; j++)
            {
                if (check_seq[j] < min)
                {
                    temp = min;
                    min = check_seq[j];
                    check_seq[j] = temp;
                }
            }
            check_seq[i] = min;
        }
        location = -1;
        for (int i = 0; i < seq_sum; i++)//查找start在该序列中的位置
        {
            if (check_seq[i] > start)
                break;
            location++;
        }
        temp = start;
        cout << "------ELEV------" << endl;
        cout << "磁头移动的轨迹:" << endl;
        if (location == -1)//磁头在最左边
        {
            for (int i = 0; i < seq_sum; i++)
            {
                cout << temp << ' ';
                mov += abs(temp - check_seq[i]);
                temp = check_seq[i];
            }
            cout << temp << endl;
        }
        else if (location == 9)//磁头在最右边
        {
            for (int i = seq_sum - 1; i >= 0; i--)
            {
                cout << temp << ' ';
                mov += abs(temp - check_seq[i]);
                temp = check_seq[i];
            }
            cout << temp << endl;
        }
        else//在中间
        {
            if (abs(check_seq[location] - start) <= abs(check_seq[location + 1] - start))//先往左扫描
            {
                for (int i = location; i >= 0; i--)
                {
                    cout << temp << ' ';
                    mov += abs(temp - check_seq[i]);
                    temp = check_seq[i];
                }
                for (int i = location + 1; i < seq_sum; i++)
                {
                    cout << temp << ' ';
                    mov += abs(temp - check_seq[i]);
                    temp = check_seq[i];
                }
                cout << temp << endl;
            }
            else//先往右扫描
            {
                for (int i = location + 1; i < seq_sum; i++)
                {
                    cout << temp << ' ';
                    mov += abs(temp - check_seq[i]);
                    temp = check_seq[i];
                }
                for (int i = location; i >= 0; i--)
                {
                    cout << temp << ' ';
                    mov += abs(temp - check_seq[i]);
                    temp = check_seq[i];
                }
                cout << temp << endl;
            }
        }
        cout << "磁头移动的总磁道数:" << mov << endl;
    }
    
    

    4、主函数代码

    #include <iostream>
    #include<cmath>
    using namespace std;
    
    void FCFS(int*, int);//先来先服务法
    void SSTF(int*, int);//最短寻道时间优先法
    void ElEV(int*, int);//电梯法
    
    int seq_sum;//序列中请求访问的磁道总数
    
    int main()
    {
        int seq[] = { 45,23,67,2,9,89,165,49,80,77 };//要请求访问的磁道序列
        int start;//磁道的开始位置
        seq_sum =sizeof(seq)/sizeof(int);
        start = rand() % 200+1;//随机选择一个磁道开始位置
        FCFS(seq, start);//先来先服务法
        SSTF(seq, start);//最短寻道时间优先法
        ElEV(seq, start);//电梯法
    }
    

    5、运行结果
    在这里插入图片描述
    6、总结
    磁盘调度算法比较容易理解,实现也比较容易。

    展开全文
  • 磁盘调度算法-SSTF.rar

    2022-03-13 16:08:28
    这是关于磁盘调度算法——SSTF的简易Visio描述图形。
  • 课程设计关于磁盘调度算法实现,有完整的源代码和文档。非常实用,方法简单易懂。
  • 操作系统实验报告三份,基于天津理工大学,实验1:处理机调度.;实验2:存储器的分配与回收;磁盘调度算法实现

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 69,623
精华内容 27,849
关键字:

磁盘调度算法的实现

友情链接: PCSpeaker.zip