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("退出");
    }
}
  • 2
    点赞
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
磁盘调度算法是指计算机操作系统中用于控制磁盘读写的算法。常见的磁盘调度算法有 FCFS、SSTF、SCAN、C-SCAN、LOOK 和 C-LOOK 等。 下面是 Java 实现 SCAN 磁盘调度算法的示例代码: ```java import java.util.ArrayList; import java.util.Collections; public class DiskScheduling { private int currentHeadPosition; private ArrayList<Integer> requests; public DiskScheduling(int currentHeadPosition, ArrayList<Integer> requests) { this.currentHeadPosition = currentHeadPosition; this.requests = requests; } public int calculateTotalHeadMovement() { int totalHeadMovement = 0; ArrayList<Integer> sortedRequests = new ArrayList<>(requests); Collections.sort(sortedRequests); int index = sortedRequests.indexOf(currentHeadPosition); // head movement in the forward direction for (int i = index; i < sortedRequests.size(); i++) { totalHeadMovement += Math.abs(sortedRequests.get(i) - currentHeadPosition); currentHeadPosition = sortedRequests.get(i); } // head movement in the backward direction for (int i = index - 1; i >= 0; i--) { totalHeadMovement += Math.abs(sortedRequests.get(i) - currentHeadPosition); currentHeadPosition = sortedRequests.get(i); } return totalHeadMovement; } public static void main(String[] args) { int currentHeadPosition = 50; ArrayList<Integer> requests = new ArrayList<>(); requests.add(82); requests.add(170); requests.add(43); requests.add(140); requests.add(24); requests.add(16); requests.add(190); DiskScheduling diskScheduling = new DiskScheduling(currentHeadPosition, requests); int totalHeadMovement = diskScheduling.calculateTotalHeadMovement(); System.out.println("Total head movement: " + totalHeadMovement); } } ``` 在上述代码中,我们首先定义了一个 `DiskScheduling` 类,其中包含当前磁头位置和请求队列两个属性,并且实现了 `calculateTotalHeadMovement` 方法来计算总的磁头移动距离。 在 `calculateTotalHeadMovement` 方法中,我们首先对请求队列进行排序,然后找到当前磁头位置在排序后的队列中的索引。接着,我们分别计算磁头向前和向后移动的距离,并将当前磁头位置更新为当前请求的位置。最终,返回总的磁头移动距离。 在 `main` 方法中,我们定义了当前磁头位置和请求队列,并使用 `DiskScheduling` 类来计算总的磁头移动距离。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值