SCAU-操作系统-题目四-磁盘调度算法的模拟实现及对比

已于 2023-06-16 13:48:11 修改
阅读量446 收藏 17
点赞数 1
文章标签： java
于 2023-06-02 10:37:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Electric_W/article/details/130932833
版权

我摆烂了你的操作系统实验作业

HelloApplication.java（懂的都懂）

package com.example.program;

import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Scene;
import javafx.stage.Stage;

import java.io.IOException;

public class HelloApplication extends Application {
    @Override
    public void start(Stage stage) throws IOException {
        FXMLLoader fxmlLoader = new FXMLLoader(HelloApplication.class.getResource("hello-view.fxml"));
        Scene scene = new Scene(fxmlLoader.load(), 800, 800);
        stage.setTitle("program4");
        stage.setScene(scene);
        stage.show();
    }

    public static void main(String[] args) {
        launch();
    }
}

HelloController.java（写了一坨） 

package com.example.program;

import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.geometry.Pos;
import javafx.geometry.Side;
import javafx.scene.chart.LineChart;
import javafx.scene.chart.NumberAxis;
import javafx.scene.chart.XYChart;
import javafx.scene.control.Label;
import javafx.scene.control.TextArea;
import javafx.scene.control.TextField;
import javafx.scene.layout.HBox;
import javafx.scene.layout.VBox;

import java.net.URL;
import java.util.ResourceBundle;


public class HelloController implements Initializable {

    @FXML
    private TextField initPos;

    @FXML
    private VBox vbox1;

    @FXML
    private HBox hbox1;

    @FXML
    private HBox hbox2;

    @FXML
    private HBox hbox3;

    @FXML
    private HBox hbox4;
    @FXML
    private HBox hbox5;
    private TextArea textArea = new TextArea();
    int[] array=new int[400];
    int start = 0;
    int fcfsPath=0;
    int[] fcfsArray = new int[400];
    int sstfPath=0;
    int[] sstfArray = new int[400];
    int lookPath=0;
    int[] lookArray = new int[400];
    int cscanPath=0;
    int[] cscanArray = new int[400];
    @FXML
    void start() {
        if (isNumeric2(initPos.getText())){
            start=Integer.parseInt(initPos.getText());
            if(start>=0&&start<1500){
                series1.getData().clear();
                series2.getData().clear();
                series3.getData().clear();
                series4.getData().clear();
                init();
                fcfs();
                sstf();
                look();
                cscan();
                for (int i =0;i<400;i++){
                    series1.getData().add(new XYChart.Data(i,fcfsArray[i]));
                    series2.getData().add(new XYChart.Data(i,sstfArray[i]));
                    series3.getData().add(new XYChart.Data(i,lookArray[i]));
                    series4.getData().add(new XYChart.Data(i,cscanArray[i]));
                }
                fcfsData.setText("FCFS总磁头移动数："+fcfsPath+"\n平均寻道长度："+((double)fcfsPath/400.0));
                sstfData.setText("SSTF总磁头移动数："+sstfPath+"\n平均寻道长度："+((double)sstfPath/400.0));
                lookData.setText("LOOK总磁头移动数："+lookPath+"\n平均寻道长度："+((double)lookPath/400.0));
                cscanData.setText("C-SCAN总磁头移动数："+cscanPath+"\n平均寻道长度："+((double)cscanPath/400.0));
            }
            else {
                textArea.appendText("\n磁头初始位置越界！请重新输入磁头初始位置（0-1500）");
            }
        }else{
            textArea.appendText("\n输入磁头初始位置输入格式不正确，请重新输入，再开始模拟！");
        }
    }
    public void init(){//磁盘磁道数为1500

        int[] array0 = new int[200];
        int[] array1 = new int[100];
        int[] array2 = new int[100];
        for(int i=0; i<200; i++){
            array0[i] = (int)(Math.random()*500);
        }
        for(int i=0; i<100; i++){
            array1[i] = 500+(int)(Math.random()*500);
        }
        for(int i=0; i<100; i++){
            array2[i] = 1000+(int)(Math.random()*500);
        }
        for (int i=0; i<400; i++){
            if (i<200){
                array[i] = array0[i];
            }
            if (i>=200&&i<300){
                array[i] = array1[i-200];
            }
            if (i>=300){
                array[i] = array2[i-300];
            }
        }
        textArea.appendText("已创建新的磁盘请求序列号队列分别如下:\n");
        for (int i=0;i<400;i++){
            if(array[i]/10==0&&array[i]!=10){
                textArea.appendText(array[i] +"       ");
            }else if((array[i]/10>0&&array[i]/10<10)||array[i]==10){
                textArea.appendText(array[i] +"     ");
            }else if((array[i]/100>0&&array[i]/100<10)||array[i]==100){
                textArea.appendText(array[i] +"   ");
            }else {
                textArea.appendText(array[i] +" ");
            }
            if(i%10==9){
                textArea.appendText("\n");
            }
        }
    }

    public void fcfs(){
        int b=start;
        fcfsPath=Math.abs(b-array[0]);
        b=array[0];
        fcfsArray[0]=array[0];
        for(int i=1;i<400;i++){
            fcfsArray[i]=array[i];
            fcfsPath+=Math.abs(fcfsArray[i-1]-fcfsArray[i]);
        }
    }
    int Smin(int b,int[] re){
        int min = Math.abs(b-re[0]);
        int j=0;
        for(int i=1;i<400;i++){
            if(re[i]<1500) {
                if (Math.abs(b - re[i]) < min) {
                    min = Math.abs(b - re[i]);
                    j = i;
                }
            }
        }
        return j;
    }
    public void sstf(){
        int c=0;
        int b=start;
        int[] re=new int[400];
        for(int i=0;i<400;i++){
            re[i]=array[i];
        }
        for(int i=0;i<400;i++){
            c=Smin(b,re);
            b=re[c];
            re[c]=99999999;
            sstfArray[i]=b;
        }
        sstfPath=Math.abs(start-sstfArray[0]);
        for(int i=1;i<400;i++){
            sstfPath+=Math.abs(sstfArray[i-1]-sstfArray[i]);
        }
    }
    public void look(){
        int c=0,b=start;
        int[] re=new int[400];
        for(int i=0;i<400;i++){
            re[i]=array[i];
        }
        for(int i=0;i<399;i++){
            for(int j=0;j<400-i-1;j++){
                if(re[j]>re[j+1]){
                    re[j]=re[j]+re[j+1];
                    re[j+1]=re[j]-re[j+1];
                    re[j]=re[j]-re[j+1];
                }
            }
        }
        for(int i=0;i<400;i++) {
            if (re[i] > b) {
                lookArray[c++] = re[i];
            }
        }
        for(int i=399;i>=0;i--) {

            if (re[i] < b) {
                lookArray[c++] = re[i];
            }
        }
        lookPath=Math.abs(start-lookArray[0]);
        for(int i=1;i<400;i++){
            lookPath+=Math.abs(lookArray[i-1]-lookArray[i]);
        }
    }
    public void cscan(){
        int c=0,b=start;
        int[] re=new int[400];
        for(int i=0;i<400;i++){
            re[i]=array[i];
        }
        for(int i=0;i<399;i++){
            for(int j=0;j<400-i-1;j++){
                if(re[j]>re[j+1]){
                    re[j]=re[j]+re[j+1];
                    re[j+1]=re[j]-re[j+1];
                    re[j]=re[j]-re[j+1];
                }
            }
        }
        for(int i=0;i<400;i++) {
            if (re[i] > b) {
                cscanArray[c++] = re[i];
            }
        }
        for(int i=0;i<400;i++) {

            if (re[i] < b) {
                cscanArray[c++] = re[i];
            }
        }
        cscanPath=Math.abs(start-cscanArray[0]);
        for(int i=1;i<400;i++){
            cscanPath+=Math.abs(cscanArray[i-1]-cscanArray[i]);
        }
    }
    NumberAxis xAxis1 = new NumberAxis();
    NumberAxis yAxis1 =new NumberAxis(0,2000,1000);
    NumberAxis xAxis2 = new NumberAxis();
    NumberAxis yAxis2 =new NumberAxis();
    NumberAxis xAxis3 = new NumberAxis();
    NumberAxis yAxis3 =new NumberAxis();
    NumberAxis xAxis4 = new NumberAxis();
    NumberAxis yAxis4 =new NumberAxis();
    LineChart<Number,Number> fcfsLineChart = new LineChart<>(xAxis1,yAxis1);
    LineChart<Number,Number> sstfLineChart = new LineChart<>(xAxis2,yAxis2);
    LineChart<Number,Number> lookLineChart = new LineChart<>(xAxis3,yAxis3);
    LineChart<Number,Number> cscanLineChart = new LineChart<>(xAxis4,yAxis4);

    XYChart.Series series1 = new XYChart.Series<>();
    XYChart.Series series2 = new XYChart.Series<>();
    XYChart.Series series3 = new XYChart.Series<>();
    XYChart.Series series4 = new XYChart.Series<>();
    Label fcfsData = new Label("FCFS总磁头移动数：0\n平均寻道长度：0");
    Label sstfData = new Label("SSTF总磁头移动数：0\n平均寻道长度：0");
    Label lookData = new Label("LOOK总磁头移动数：0\n平均寻道长度：0");
    Label cscanData = new Label("C-SCAN总磁头移动数：0\n平均寻道长度：0");


    @Override
    public void initialize(URL url, ResourceBundle resourceBundle) {
        xAxis1 = new NumberAxis();
        yAxis1 =new NumberAxis(0,1600,100);
        xAxis2 = new NumberAxis();
        yAxis2 =new NumberAxis(0,1600,100);
        xAxis3 = new NumberAxis();
        yAxis3 =new NumberAxis(0,1600,100);
        xAxis4= new NumberAxis();
        yAxis4 =new NumberAxis(0,1600,100);
        fcfsLineChart = new LineChart<>(xAxis1,yAxis1);
        sstfLineChart= new LineChart<>(xAxis2,yAxis2);
        lookLineChart= new LineChart<>(xAxis3,yAxis3);
        cscanLineChart= new LineChart<>(xAxis4,yAxis4);
        series1 = new XYChart.Series<>();
        series2 = new XYChart.Series<>();
        series3 = new XYChart.Series<>();
        series4 = new XYChart.Series<>();
        fcfsLineChart.setTitle("FCFS");
        fcfsLineChart.setTitleSide(Side.BOTTOM);
        sstfLineChart.setTitle("SSFT");
        sstfLineChart.setTitleSide(Side.BOTTOM);
        lookLineChart.setTitle("LOOK");
        lookLineChart.setTitleSide(Side.BOTTOM);
        cscanLineChart.setTitle("C-SCAN");
        cscanLineChart.setTitleSide(Side.BOTTOM);
        fcfsLineChart.getData().addAll(series1);
        sstfLineChart.getData().addAll(series2);
        lookLineChart.getData().addAll(series3);
        cscanLineChart.getData().addAll(series4);
        // xAxis.setLabel("磁盘调度顺序");
        // yAxis.setLabel("当前位置");
        hbox1.getChildren().addAll(fcfsLineChart,fcfsData);
        hbox1.setAlignment(Pos.CENTER);
        hbox2.getChildren().addAll(sstfLineChart,sstfData);
        hbox2.setAlignment(Pos.CENTER);
        hbox3.getChildren().addAll(lookLineChart,lookData);
        hbox3.setAlignment(Pos.CENTER);
        hbox4.getChildren().addAll(cscanLineChart,cscanData);
        hbox4.setAlignment(Pos.CENTER);
        hbox5.getChildren().addAll(textArea);
        hbox5.setAlignment(Pos.CENTER);
    }
    public static boolean isNumeric2(String str) {
        if (!str.matches("^[0-9]+[0-9]*$")) {
            return false;
        }
        return true;
    }
}

源文件和研究报告在 

Electric-W/SCAU-OS (github.com)https://github.com/Electric-W/SCAU-OS

Electric_W
关注
磁盘调度算法模拟
Guang_Novak的博客
03-14 3386
2017年3月 操作系统课程设计作品：磁盘调度算法模拟 目的：了解磁盘管理的原理，掌握磁盘调度种算法。 设计要求：编程序实现下述磁盘调度算法，并求出每种算法的平均寻道长度：要求设计主界面可以灵活选择算法，且以下算法都要实现。 （1）     先来先服务算法（FCFS） （2）     最短寻道时间优先算法（SSTF） （3）     扫描算法（SCAN） （4）     循环扫描算
OS操作系统课程设计模拟磁盘管理系统SCAU
05-06
磁盘文件模拟系统 介绍 华南农业大学SCAU操作系统OS课程设计，JAVAFX开发，可以实现查找文件，磁盘空间使用情况可视化，观察每一个磁盘块的情况。完成文件的基本操作，界面数据实时更新。当时这个课设的成绩是全班第一，如果对你有帮助，麻烦点个小星星鸭~ 模拟磁盘的FAT，磁盘分配，磁盘空间管理，磁盘块读写，以及可视化该过程，用JAVAFX界面实现实时交互。可以查找相应文件文件夹，支持输入路径查找文件，以及实现文件目录树。 界面交互使用的是JAVA中的绑定与监听，能够根据数据变化时刻更新。数据以对象保存在文件中 JAVAFX依赖的包放在了lib文件夹中。
操作系统———磁盘调度算法模拟
weixin_62659979的博客
12-09 2067
【代码】操作系统———磁盘调度算法模拟。
操作系统实验4—磁盘调度
qq_42582489的博客
01-30 7443
操作系统实验4—磁盘调度 文章目录操作系统实验4—磁盘调度实验描述设计思路上机代码测试结果心得体会 实验描述 实验内容： 编写一个磁盘调度程序，模拟操作系统对磁盘的调度。 实验目的： 本实验要求学生独立设计并实现磁盘调度模拟程序，以加深对磁盘调度特点和各种磁盘调度算法的理解。 实验要求： 可以随机输入磁道请求序列，当前磁头位置和磁头移动方向，支持先来先服务、最短寻道时间优先、扫描、循环扫描调度算法，能够输出磁头移动经过的磁道序列。具体信息见测试用例格式说明。 测试用例格式如下： 输入： 磁盘调度算法 当前磁
操作系统实验四：仿真各种磁盘调度算法
05-31
内含实验报告+代码（源代码+可执行文件）+截图+画图
操作系统课设磁盘调度算法的模拟与实现
qq_62710910的博客
06-22 2006
然后先累加大于初始磁道的磁道，当访问到Max数组最后一个磁道时，跳转回Mins数组，用Maxs数组的最后一个磁道与Mins数组最后一个磁道相减的差值记录下来，然后反向扫描Mins数组，记录相邻磁道的磁道值的差值，用于最后求平均磁道长度。最短服务时间优先算法比FIFO要复杂一些，首先我们要使用双重循环，从所有未被访问的磁道中找到距离上一个磁道距离最近的磁道，记录他们之间的距离，然后将该磁道放入被访问的磁道数组中，同时更改该磁道的标志为true，避免重复查找；array[N]：用来记录初始的磁道序列。
操作系统课程设计--磁盘调度算法的模拟实现及对比
05-28
NULL 博文链接：https://bosshida.iteye.com/blog/620814
华农磁盘调度算法的模拟及对比
06-06
《磁盘调度算法的模拟及对比》 在操作系统中，磁盘调度算法是管理硬盘读写请求的关键技术，它决定了I/O操作的效率和响应时间。本文将详细探讨磁盘调度算法，特别是从C#编程角度出发，模拟并对比几种常见的磁盘调度...
SCAU操作系统实验报告源码 题目：调度算法
07-13
在"OperatingSystem"这个压缩包中，可能包含了实现这四种调度算法的源代码，以及实验环境和实验步骤。通过分析和运行这些代码，你可以更深入地理解这些调度算法的工作原理，以及它们如何影响操作系统的整体性能。...
操作系统实验：页面置换算法的模拟实现及命中率对比.rar
06-28
本资源使用Java实现了页面置换算法OPT、...该资源的文字版信息请访问博客《操作系统实验：页面置换算法的模拟实现及命中率对比（学习笔记）》（https://blog.csdn.net/weixin_40589192/article/details/106997447）。
磁盘调度算法（操作系统实验 C＋＋）
落灬枫的博客
04-03 3394
通过这次实验，加深对磁盘调度算法的理解，进一步掌握先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法的实现方法。
实验（四）磁盘调度算法模拟
凤文Sharing的博客
12-06 3860
磁盘调度算法模拟）一、实验名称二、实验目的三、实验内容和要求四、实验设计1、程序流程图：2、实验环境：jdk1.83、代码与注释五、实验步骤及实验结果1、实验内容2、实验结果六、实验中出现的问题及解决方法问题1：SSTF算法的实现七、结论 一、实验名称 实验（四）磁盘调度算法模拟 二、实验目的 掌握磁盘调度的策略及原理，理解和掌握磁盘调度算法——先来先服务算法（FCFS）、最短寻道时间优先算法（SSTF）、电梯扫描算法（SCAN），比较各算法相关特性。 三、实验内容和要求 （1）模拟先来先服务法（FCFS）
操作系统——磁盘调度算法的模拟与实现
CSH__的博客
06-25 1046
操作系统课设：实验六
操作系统实验：磁盘调度算法模拟（FIFO，SSTF，SCAN，C-SCAN）
qq_45811908的博客
06-19 1623
磁盘调度算法模拟（FIFO，SSTF，SCAN，C-SCAN） 1.都是从磁道号为100开始。 2.其中SCAN和C-SCAN都是让他们从离100较近的方向开始的。 #include <stdio.h> #include <math.h> #include <stdlib.h> //先进先出 void FIFO(int a[], int n) { int i; int sum = 0, num; for (i = 0; i < n - 2; i++)
磁盘调度算法的模拟与实现
xzzszka的博客
08-15 3153
1、实验目的 (1) 了解磁盘结构以及磁盘上数据的组织方式。 (2) 掌握磁盘访问时间的计算方式。 (3) 掌握常用磁盘调度算法及其相关特性。 2、实验基本知识及原理 （1）磁盘数据的组织 磁盘上每一条物理记录都有唯一的地址，该地址包括三个部分：磁头号（盘面号）、柱面号（磁 道号）和扇区号。给定这三个量就可以唯一地确定一个地址。 （2）磁盘访问时间的计算方式 磁盘在工作时以恒定的速率旋转。为保证读或写，磁头必须移动到所要求的磁道上，当所要求 的扇区的开始位置旋转到磁头下时，开始读或写数据。对磁盘的访问时间包
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 307
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
Mybatis
最新发布
庸不易的博客
11-15 404
1、定义不同：#{} 预处理：而 ${} 是直接替换2、使用不同：#{} 适用于所有类型的参数匹配；但 ${} 只适用于数值类型。3、安全性不同：#{} 性能高，并且没有安全问题；但 $ {} 存在 SQL 注入的安全问题。4、使用场景不同：当传递的是一个 SQL 关键字 的时候，只能 使用 ${}。当传递的是一个字段，总之，就是需要获取到参数类型 与 内容，只能使用 #{}。（PS：数字类型，#{} 和 ${} 都是可以使用的！5、 ${} 不能用于 模糊匹配查询；
1112--接口
kequanrrr的博客
11-12 434
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
刷题---顺序表算法题
weixin_63997543的博客
11-11 448
顺序算法题----力扣刷题
SCAU操作系统实验报告：四大调度算法解析
知识点五：操作系统调度算法的选择与实现 在选择调度算法时，需要考虑系统的类型（批处理系统、分时系统等）、进程的特性（CPU密集型或I/O密集型）、系统的实时性要求等多个因素。不同的调度算法适用于不同的应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值