操作系统 磁盘调度算法 JAVA语言设计程序 模拟 先来先服务FCFS，最短寻道时间优先SSTF，扫描SCAN，循环扫描SCAN算法的工作过程 及平均寻道长度

最新推荐文章于 2024-05-06 21:32:45 发布
最新推荐文章于 2024-05-06 21:32:45 发布
阅读量416 收藏 9
点赞数 6
分类专栏： Java 文章标签： java 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ATsar/article/details/135040546
版权

问题描述：

设计程序模拟先来先服务FCFS，最短寻道时间优先SSTF，SCAN和循环SCAN算法的工作过程。假设有n个磁道号所组成的磁道访问序列，给定开始磁道号m和磁头移动的方向（正向或者反向），分别利用不同的磁盘调度算法访问磁道序列，给出每一次访问的磁头移动距离，计算每种算法的平均寻道长度。

程序要求如下：

1）利用先来先服务FCFS，最短寻道时间优先SSTF，SCAN和循环SCAN算法模拟磁道访问过程。

2）模拟四种算法的磁道访问过程，给出每个磁道访问的磁头移动距离。

3）输入：磁道个数n和磁道访问序列，开始磁道号m和磁头移动方向（对SCAN和循环SCAN算法有效），算法选择1-FCFS，2-SSTF，3-SCAN，4-循环SCAN。

4）输出：每种算法的平均寻道长度。

例题：当前磁头停在100号磁道，有15个磁道请求先后到达，依次为64，117， 305，72，166，288，193，11，102，219，95，321，35，146，188，计算FCFS，SSTF，SCAN(向里), CSCAN（向外），这四种算法的平均寻道长度。

package HomeWork_OS.DiskSchedulingAlgorithm;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;

public class disk_Algorithm {

    static int totleDistance = 0; //总移动磁道数
    static int totleDisk = 0;      //总磁盘数


    //平均寻道长度
    public static void avgSeekTime(int totleDistance, int totleDisk) {
        double avgSeekTime = (double) totleDistance / totleDisk;//平均寻道时间
        System.out.println("平均寻道长度: " + String.format("%.4f", avgSeekTime) + "\n");

    }

    /*先来先服务FCFS*/
    public static void FCFS(int[] arr, int head) {//磁道抵达数组，当前停留磁头号
        totleDisk = arr.length;//获得总磁盘数
        totleDistance = 0;//清空总磁道移动距离
        //新建一个二维数组存访问的磁道号和移动距离
        int[][] resultArr = new int[arr.length][2];
        //设置一个存储当前磁头号的标识
        int diskNo = head;
        //遍历磁道抵达数组
        for (int i = 0; i < arr.length; i++) {
            resultArr[i][0] = arr[i];
            resultArr[i][1] = (int) Math.abs(arr[i] - diskNo);
            diskNo = resultArr[i][0];
        }
        System.out.println("访问磁道号" + "\t\t移动距离<磁道数>");
        for (int i = 0; i < resultArr.length; i++) {
            System.out.println(resultArr[i][0] + "\t\t\t\t" + resultArr[i][1]);
            totleDistance += resultArr[i][1];
        }
        avgSeekTime(totleDistance, totleDisk);
    }

    /*最短寻道时间优先SSTF*/
    public static void SSTF(int[] arr, int head) {
        totleDisk = arr.length;//获得总磁盘数
        totleDistance = 0;//清空总磁道移动距离
        //新建一个链表用来存储磁道号的数组
        List diskList = new LinkedList();
        //将磁道号数组,存入链表
        for (int i : arr) {
            diskList.add(i);
        }
//        System.out.println(diskList);
        System.out.println("访问磁道号" + "\t\t移动距离<磁道数>");
        for (int i = 0; i < arr.length; i++) {
            //最小移动距离,初始为当前磁头号到链表中第一个元素的绝对值
            int minDistance = Math.abs(head - (int) diskList.get(0));
            //最小移动距离的磁道号,初始值为链表中第一个元素
            int minDiskNo = (int) diskList.get(0);
            //链表中最小移动距离磁道号索引
            int removeIndex = 0;
            //遍历链表，找出离当前磁头最近的磁道号
            for (int size = diskList.size(), j = 0; j < size; j++) {
                if (minDistance > (int) Math.abs(head - (int) diskList.get(j))) {
                    minDistance = (int) Math.abs(head - (int) diskList.get(j));
                    minDiskNo = (int) diskList.get(j);
                    removeIndex = j;
                }
            }
            totleDistance += minDistance;
            //将头节点设为目前最小运动距离磁道号->头节点移动到当前最小移动距离磁道号
            head = minDiskNo;
            //从链表中移除最小移动距离的磁道号
            diskList.remove(removeIndex);
            System.out.println(minDiskNo + "\t\t\t\t" + minDistance);
//            System.out.println(diskList);
        }
        avgSeekTime(totleDistance, totleDisk);
    }

    /*扫描SCAN算法*/
    public static void SCAN(int[] arr, int head, boolean flag) { //flag传入方向 true->1外向 false->0里向(向外为磁道号增大的方向移动)
   /*     System.out.println("===============");
        System.out.println("head: " + head);
        System.out.println("flag: " + flag);*/
        totleDisk = arr.length;//获得总磁盘数
        totleDistance = 0;//清空总磁道移动距离
        //新建一个链表用来存储磁道号的数组
        List diskList = new LinkedList();
        for (int i : arr) {
            diskList.add(i);
        }
        //给链表排序(从小到大排序)
        Collections.sort(diskList);
        System.out.println(diskList);

        //链表中最小移动距离磁道号索引
        int index = 0;
        //遍历链表
        for (int size = diskList.size(), j = 0; j < size; j++) {
            //根据需要寻道的方向,找到离当前磁道号最近的磁道
            if ((int) diskList.get(j) == head) {
                index = j;
                break;//结束循环
            } else if ((int) diskList.get(j) >= head) { //找出head右侧最近的磁道号
                index = j;
                break;

            }else if(j == size -1){
                index = j;
                break;
            }
        }
        //移动距离,初始为当前磁头号到链表中第一个元素的绝对值
        int distance;
        int size = diskList.size();
        System.out.println("访问磁道号" + "\t\t移动距离<磁道数>");
        if (flag) {
            for (int j = 0; j < size - index; j++) {
                distance = Math.abs(head - (int)diskList.get(index + j));
                totleDistance += distance;
                head = (int)diskList.get(index + j);
                System.out.println((int) diskList.get(index + j) + "\t\t\t\t" + distance);
            }
            for (int j = index - 1; j >= 0; j--) {
                distance = Math.abs(head - (int)diskList.get(j));
                totleDistance += distance;
                head = (int)diskList.get(j);
                System.out.println((int) diskList.get(j) + "\t\t\t\t" + distance);
            }

        } else {
            //当当前磁头号恰好在要扫描的磁道上时,或着当前磁头号大于要扫描的所有磁道号
            if ((int)diskList.get(index) == head || index == diskList.size() - 1){
                System.out.println("index: " + index);
                for (int j = index; j >= 0; j--) {
                    distance = Math.abs(head - (int)diskList.get(j));
                    totleDistance += distance;
                    head = (int)diskList.get(j);
                    System.out.println((int) diskList.get(j) + "\t\t\t\t" + distance);
                }
                for (int j = 1; j < size - index; j++) {
                    distance = Math.abs(head - (int)diskList.get(index + j));
                    totleDistance += distance;
                    head = (int)diskList.get(index + j);
                    System.out.println((int) diskList.get(index + j) + "\t\t\t\t" + distance);
                }

            } else {
                System.out.println("index: " + index);
                for (int j = index - 1; j >= 0; j--) {
                    distance = Math.abs(head - (int)diskList.get(j));
                    totleDistance += distance;
                    head = (int)diskList.get(j);
                    System.out.println((int) diskList.get(j) + "\t\t\t\t" + distance);
                }
                for (int j = 0; j < size - index ; j++) {
                    distance = Math.abs(head - (int)diskList.get(index + j));
                    totleDistance += distance;
                    head = (int)diskList.get(index + j);
                    System.out.println((int) diskList.get(index + j) + "\t\t\t\t" + distance);
                }
            }
        }
        avgSeekTime(totleDistance,totleDisk);
    }



    /*循环扫描CSCAN*/
    public static void CSCAN(int[] arr, int head, boolean flag) { //flag传入方向 true->1向外 false->0向里
/*        System.out.println("===============");
        System.out.println("head: " + head);
        System.out.println("flag: " + flag);*/
        totleDisk = arr.length;//获得总磁盘数
        totleDistance = 0;//清空总磁道移动距离
        //新建一个链表用来存储磁道号的数组
        List diskList = new LinkedList();
        for (int i : arr) {
            diskList.add(i);
        }
        //给链表排序(从小到大排序)
        Collections.sort(diskList);
        System.out.println(diskList);
        //链表中最小移动距离磁道号索引
        int index = 0;
        //遍历链表
        for (int size = diskList.size(), j = 0; j < size; j++) {
            //根据需要寻道的方向,找到离当前磁道号最近的磁道
            if ((int) diskList.get(j) == head) {
                index = j;
                break;//结束循环
            } else if ((int) diskList.get(j) >= head) { //找出head右侧最近的磁道号
                index = j;
                break;
            }else if(j == size -1){
                index = j;
                break;
            }
        }
        //移动距离,初始为当前磁头号到链表中第一个元素的绝对值
        int distance;
        int size = diskList.size();
//        System.out.println("index: " + index);
        System.out.println("访问磁道号" + "\t\t移动距离<磁道数>");
        if (flag) {
            if ((int) diskList.get(index) < head)
                index = 0;
            for (int j = 0; j < size - index; j++) {
                distance = Math.abs(head - (int)diskList.get(index + j));
                totleDistance += distance;
                head = (int)diskList.get(index + j);
                System.out.println((int) diskList.get(index + j) + "\t\t\t\t" + distance);
            }
            for (int j = 0; j < index; j++) {
                distance = Math.abs(head - (int)diskList.get(j));
                totleDistance += distance;
                head = (int)diskList.get(j);
                System.out.println((int) diskList.get(j) + "\t\t\t\t" + distance);
            }

        } else {
            //当当前磁头号恰好在要扫描的磁道上时,或着当前磁头号大于要扫描的所有磁道号
            if ((int) diskList.get(index) > head && index != 0)
                index = index - 1;

//            System.out.println("index: " + index);
            for (int j = index; j >= 0; j--) {
                distance = Math.abs(head - (int)diskList.get(j));
                totleDistance += distance;
                head = (int)diskList.get(j);
                System.out.println((int) diskList.get(j) + "\t\t\t\t" + distance);
            }
            for (int j = size - 1; j > index ; j--) {
                distance = Math.abs(head - (int)diskList.get(j));
                totleDistance += distance;
                head = (int)diskList.get(j);
                System.out.println((int) diskList.get(j) + "\t\t\t\t" + distance);
            }

        }
        avgSeekTime(totleDistance,totleDisk);
    }


    public static void main(String[] args) {
        /*测试用例一
        * 9
        * 55 58 39 18 90 160 150 38 184
        * 100
        * */
        /*测试用例二
        * 15
        * 64 117 305 72 166 288 193 11 102 219 95 321 35 146 188
        * 100
        * */
        Scanner sc = new Scanner(System.in);
        boolean flag = true;
        System.out.print("请输入提出磁盘I/O申请的进程数: ");
        int inputDiskNum = sc.nextInt(); //用户键盘输入进程数
        int[] diskArr = new int[inputDiskNum];
        System.out.print("请依次输入要访问的磁道号: ");
        for (int i = 0; i < diskArr.length; i++) {
            diskArr[i] = sc.nextInt();
        }
        System.out.print("请输入开始的磁道号: ");
        int inputDiskHead = sc.nextInt();
        int userOption;

        boolean direction;
        while (flag) {
            System.out.print("请选择寻道方式: " +
                    "\n1——FCFS 2——SSTF 3——SCAN 4——CSCSN: ");
            userOption = sc.nextInt();
            switch (userOption) {
                case 1:
                    FCFS(diskArr, inputDiskHead);
                    System.out.print("是否继续选择寻道算法? 1——是 0——否: ");
                    flag = sc.nextInt() > 0 ? true : false;
                    break;
                case 2:
                    SSTF(diskArr, inputDiskHead);
                    System.out.print("是否继续选择寻道算法? 1——是 0——否: ");
                    flag = sc.nextInt() > 0 ? true : false;
                    break;
                case 3:
                    System.out.print("请选择开始方向: 1——向外 0——向里: ");
                    direction = sc.nextInt() > 0 ? true : false;
                    SCAN(diskArr, inputDiskHead, true);

                    System.out.print("是否继续选择寻道算法? 1——是 0——否: ");
                    flag = sc.nextInt() > 0 ? true : false;
                    break;
                case 4:
                    System.out.print("请选择开始方向: 1——向外 2——向里: ");
                    direction = ((sc.nextInt() > 0) ? true : false);
                    CSCAN(diskArr, inputDiskHead, true);

                    System.out.print("是否继续选择寻道算法? 1——是 0——否: ");
                    flag = sc.nextInt() > 0 ? true : false;
                    break;
                default:
                    System.out.println("输入有误,请重新输入! ");
                    break;
            }
            System.out.println( flag ? "" : "成功退出程序！！");
        }



//        int[] diskArr = new int[]{64, 117, 305, 72, 166, 288, 193, 11, 102, 219, 95, 321, 35, 146, 188};
//        FCFS(diskArr, 100);
//        SSTF(diskArr, 100);
//        SCAN(diskArr, 100, true);
//        CSCAN(diskArr, 100, true);


        /*测试用例*/
/*        int[] testArr = new int[]{55, 58, 39, 18, 90, 160, 150, 38, 184};
        FCFS(testArr, 100);
        SSTF(testArr, 100);
        SCAN(testArr, 100, true);
        CSCAN(testArr, 100, true);

        FCFS(testArr,100);
        SSTF(testArr, 100);
        SCAN(testArr,100,true);
        SCAN(testArr,100,false);

        SCAN(testArr,10,true);
        SCAN(testArr,10,false);
        SCAN(testArr,18,false);
        SCAN(testArr,18,true);
        SCAN(testArr,200,false);
        SCAN(testArr,200,true);
        SCAN(testArr,160,false);
        SCAN(testArr,160,true);

        CSCAN(testArr,10,true);
        CSCAN(testArr,100,true);
        CSCAN(testArr,160,true);
        CSCAN(testArr,200,true);
        CSCAN(testArr,10,false);
        CSCAN(testArr,100,false);
        CSCAN(testArr,160,false);
        CSCAN(testArr,200,false);
        CSCAN(testArr,19,false);*/



    }
}

运行截图：

_Domineering
关注
  • 6
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
磁盘调度算法(最短寻道时间优先算法(SSTF) 扫描算法(SCAN) 先来先服务算法(FCFS) 循环扫描算法(CSCAN)....)
04-30
最短寻道时间优先算法(SSTF) 扫描算法(SCAN) 先来先服务算法(FCFS) 循环扫描算法(CSCAN)....
磁盘调度算法
weixin_30770783的博客
04-05 846
磁盘调度算法 磁盘调度在多道程序设计的计算机系统中，各个进程可能会不断提出不同的对磁盘进行读/写操作的请求。由于有时候这些进程的发送请求的速度比磁盘响应的还要快，因此我们有必要为每个磁盘设备建立一个等待队列，常用的磁盘调度算法有以下四种： [1] 先来先服务算法（FCFS）， 最短寻道时间优先算法（SSTF）， 扫描算法（SCAN）， 循环扫描算法（CSCAN） ...
【操作系统】磁盘调度算法 先来先服务、最短寻道时间优先、扫描算法、循环扫描算法
qq_55930097的博客
07-11 7788
本次实验通过模拟磁盘调度及进程排队算法来加深了对操作系统中各个磁盘调度算法概念的理解，实现各种不同调度算法的过程，并计算不同算法的平均寻道长度，以便于我们判断各种算法的优劣以及各种算法使用的场合。其中先来先服务算法是最简单的磁盘调度算法，它根据进程请求访问磁盘的顺序服务；最短寻道时间优先算法根据磁头的当前位置首先将请求队列中距磁头最短的请求为之服务；扫描算法也叫电梯调度算法，磁头固定从外向内然后从内向外逐柱面运动，如此往复；循环扫描算法的磁头从盘面上的一端向另一端移动，遇到请求立即服务。
磁盘调度算法之先来先服务(FCFS)，最短寻找时间优先(SSTF)，扫描算法(SCAN，电梯算法)，LOOK调度算法
jungleirim的博客
10-29 3676
扫描算法（SCAN)中，只有到达最边上的磁道时才能改变磁头移动方向，事实上，处埋了184号磁道的访问请求之后就不需要再往右移动磁头了。本例中，如果在处理18号磁道的访问请求时又来了一个38号磁道的访问请求，处理38号磁道的访问请求时又来了一个18号磁道的访问请求。C-SCAN算法的主要缺点是只有到达最边上的磁道时才能改变磁头移动方向，并且磁头返回时不一定需要返回到最边缘的磁道上。如果磁头移动的万同上已绘没有磁道访问请求了，就可以立即让磁头返回，并且磁头只需要返回到有磁道访问请求的位置即可。
磁盘调度算法（操作系统实验 C＋＋）
落灬枫的博客
04-03 2753
通过这次实验，加深对磁盘调度算法的理解，进一步掌握先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法的实现方法。
磁盘调度算法 先来先服务（FCFS） 最短寻道时间优先（SSTF） Java实现
weixin_45761769的博客
12-23 3292
广东工业大学 操作系统实验 实验原理 代码实现 1. 先来先服务（FCFS） import java.util.Scanner; public class FCFS { Scanner scan = new Scanner(System.in); int[] req; int num; int[] move; void input() { System.out.print("请输入进程数："); num = scan.nextInt(); req = new int[n
磁盘调度算法：最短寻道时间优先（SSTF）和扫描（SCAN）算法
12-30
最短寻道时间优先（SSTF）和扫描（SCAN）算法。理解各调度算法的工作原理 对给出的任意的磁盘请求序列、计算平均寻道长度；要求可定制磁盘请求序列长度、磁头起始位置、磁头移动方向。 测试：假设磁盘访问序列：98，...
磁盘调度算法（报告和源代码）-包括先来先服务、最短寻道时间优先、扫描算法和循环扫描算法
07-11
设计程序模拟先来先服务FCFS、最短寻道时间优先SSTF、扫描算法（SCAN）和循环扫描算法（CSCAN）的工作过程。
基于java图形界面的磁盘调度算法实现---先来先服务&最短寻道&扫描算法
10-14
基于java图形界面开发出“Stephen的磁盘调度mini模拟器”，实现出先来先服务&最短寻道&扫描算法&循环扫描算法的执行效果。
磁盘调度先来先服务 最短寻道时间优先
05-18
FCFS SSTF SCAN 算法 先来先服务 最短寻道时间优先 扫描
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。
XING的博客
05-03 1203
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。数据库作为系统数据储存平台，实现了基于B/S结构的Web系统。界面简洁，操作简单。采用M（model）V（view）C（controller）三层体系结构，通过。
JAVA 学习·泛型（二）——通配泛型
wr114514的博客
05-02 1076
介绍了Java泛型中的重要知识点——通配泛型及其应用。
Java---类和方法的再学习
m0_74012211的博客
05-05 1118
Java类与对象
【Java基础】三大特性——多态
qq_43714449的博客
05-05 407
它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。实现一个功能时，功能的一部分是确定的，一部分是不确定，确定的部分还会用到不确定的部分，那么就把不确定的部分暴露出去，让子类去实现。通常通过重写toString方法，来返回有用的数据。instanceof 是 Java 的一个二元操作符，类似于 ==，>，< 等操作符。确定的部分：记录一个开始时间，记录一个结束时间，结束时间 - 开始时间。对类存在的语法，对接口也存在。，返回对象的字符串表示形式。判断两个人是否是同龄人。
Kubernetes基础(二十九)-资源预留
sre救赎之路
05-05 916
如果还设置了对应的 --system-reserved-cgroup 和 --kube-reserved-cgroup参数，Pod能实际使用的资源上限不会改变（即kubepods.limit_in_bytes不变），但系统进程与kube进程也会受到资源上限的限制。比如某个节点的内存的allocatable为10Gi，有三个Pod（requests.memory=3Gi）已经调度到该节点上，那么第4个Pod就无法调度到该节点上，即使该Node上的空闲内存大于3Gi。
如何用Jmeter压测
最新发布
howard1209a的博客
05-06 388
可以从清华源下载，我下的是 5.6.3 版本。bin 目录打开终端，输入 Jmeter 运行Options 点 Choose language 选择中文。
Java | Leetcode Java题解之第62题不同路径
m0_57195758的博客
05-01 577
Java | Leetcode Java题解之第62题不同路径
掌握先来先服务FCFS，最短寻道时间优先SSTF，SCAN和循环SCAN算法。
06-02
先来先服务（FCFS）算法是一种简单的调度算法，按照作业提交的顺序进行调度。该算法存在“平均等待时间长”的缺点，因为作业的提交顺序可能与作业的执行顺序不匹配。 最短寻道时间优先（SSTF）算法是一种基于磁头移动距离的调度算法，每次选择距离当前磁头位置最近的请求进行调度。该算法能够减少平均寻道时间，但可能会导致某些请求长时间等待。 SCAN算法是一种扫描算法，磁头在一端向另一端移动，处理请求的顺序与磁头移动方向相同。当磁头到达磁盘的一端时，它会反转方向并继续处理请求，直到到达另一端。该算法优先处理距离当前磁头位置最近的请求，能够缩短等待时间，但可能会导致某些请求长时间等待。 循环SCAN算法是SCAN算法的变体，当磁头到达磁盘的一端时，它会回到另一端继续处理请求。该算法能够平衡磁头移动距离，减少寻道时间，但可能会导致某些请求长时间等待。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值