磁盘调度算法

磁盘调度在多道程序设计的计算机系统中，各个进程可能会不断提出不同的对磁盘进行读/写操作的请求。由于有时候这些进程的发送请求的速度比磁盘响应的还要快，因此我们有必要为每个磁盘设备建立一个等待队列，常用的磁盘调度算法有以下四种：

先来先服务算法（FCFS），

最短寻道时间优先算法（SSTF），

扫描算法（SCAN），

循环扫描算法（CSCAN）

例:假定某磁盘共有200个柱面，编号为0-199，如果在为访问143号柱面的请求者服务后，当前正在为访问125号柱面的请求服务，同时有若干请求者在等待服务，它们每次要访问的柱面号为   86，147，91，177，94，150，102，175，130

1、先来先服务算法（FCFS）First Come First Service

这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化，在对磁盘的访问请求比较多的情况下，此算法将降低设备服务的吞吐量，致使平均寻道时间可能较长，但各进程得到服务的响应时间的变化幅度较小。

先来先服务 （125）86.147.91.177.94.150.102.175.130

2、最短寻道时间优先算法（SSTF） Shortest Seek Time First

该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，该算法可以得到比较好的吞吐量，但却不能保证平均寻道时间最短。其缺点是对用户的服务请求的响应机会不是均等的，因而导致响应时间的变化幅度很大。在服务请求很多的情况下，对内外边缘磁道的请求将会无限期的被延迟，有些请求的响应时间将不可预期。

最短寻道时间优先（125）130.147.150.175.177.102.94.91.86

3、扫描算法（SCAN）电梯调度

扫描算法不仅考虑到欲访问的磁道与当前磁道的距离，更优先考虑的是磁头的当前移动方向。例如，当磁头正在自里向外移动时，扫描算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外，又是距离最近的。这样自里向外地访问，直到再无更外的磁道需要访问才将磁臂换向，自外向里移动。这时，同样也是每次选择这样的进程来调度，即其要访问的磁道，在当前磁道之内，从而避免了饥饿现象的出现。由于这种算法中磁头移动的规律颇似电梯的运行，故又称为电梯调度算法。此算法基本上克服了最短寻道时间优先算法的服务集中于中间磁道和响应时间变化比较大的缺点，而具有最短寻道时间优先算法的优点即吞吐量较大，平均响应时间较小，但由于是摆动式的扫描方法，两侧磁道被访问的频率仍低于中间磁道。

电梯调度（125）102.94.91.86.130.147.150.175.177

4、循环扫描算法（CSCAN）

循环扫描算法是对扫描算法的改进。如果对磁道的访问请求是均匀分布的，当磁头到达磁盘的一端，并反向运动时落在磁头之后的访问请求相对较少。这是由于这些磁道刚被处理，而磁盘另一端的请求密度相当高，且这些访问请求等待的时间较长，为了解决这种情况，循环扫描算法规定磁头单向移动。例如，只自里向外移动，当磁头移到最外的被访问磁道时，磁头立即返回到最里的欲访磁道，即将最小磁道号紧接着最大磁道号构成循环，进行扫描。

循环扫描 （125）130.147.150.175.177.86.91.94.102

package opp;

import java.util.Arrays;
import java.util.Scanner;
import java.util.Stack;

public class Main {
    public static boolean judge(String choice) {
        if (choice.matches("[0-4]")) {
            return true;
        }
        return false;
    }

    public static int Menu() {
        while (true) {
            System.out.println("=============================");
            System.out.println("           磁盘调度                   ");
            System.out.println("=============================");
            System.out.println("1.先来先服务");
            System.out.println("2.最短寻道时间优先");
            System.out.println("3.扫描算法");
            System.out.println("4.循环扫描算法");
            System.out.println("0.结束");
            System.out.println("=============================");
            Scanner cin = new Scanner(System.in);
            int num = cin.nextInt();
            if (judge(num + "") == false) {
                System.out.println("您的输入有误,请重新输入!");
            } else {
                return num;
            }
        }

    }

    public static void main(String[] args) {
        while (true) {
            int choice = Menu();
            switch (choice) {
            case 1: {
                FCFS();
                break;
            }
            case 2: {
                SSTF();
                break;
            }
            case 3: {
                SCAN();
                break;
            }
            case 4: {
                CSCAN();
                break;
            }
            default: {
                break;
            }
            }
        }

    }

    private static void Input(int num[], int str[], int cur[]) {
        Scanner cin = new Scanner(System.in);
        System.out.println("输入磁道数：");
        num[0] = cin.nextInt();
        System.out.println("每个磁道：");
        for (int i = 0; i < num[0]; i++) {
            str[i] = cin.nextInt();
        }
        System.out.println("开始磁道：");
        cur[0] = cin.nextInt();
    }

    private static void CSCAN() {
        int[] num = new int[1];
        int[] cur = new int[1];
        int[] str = new int[1000];
        int[] dis = new int[1000];
        int[] next = new int[1000];
        Input(num, str, cur);
        int[] sum = new int[1];

        calFour(num[0], str, cur[0], next, sum, dis);
        Output(str, sum[0], dis, num[0]);

    }

    private static void calFour(int num, int[] str, int cur, int[] next, int[] sum, int[] dis) {
        for (int i = 0, len = str.length; i < len; i++) {
            if (str[i] == 0)
                str[i] = 0x3f3f3f3f;
        }
        Arrays.sort(str);
        int[] vis = new int[num];
        int cnt = 0;

        int curx = -1;
        for (int i = 0; i < num; i++) {
            if (str[i] >= cur && vis[i] == 0) {
                curx = i;
                break;
            }

        }
        for (int i = curx; i < num; i++) {
            next[cnt++] = str[i];
            dis[cnt - 1] = abs(cur - next[cnt - 1]);
            sum[0] += abs(cur - next[cnt - 1]);
            cur = str[i];
        }
        for (int i = 0; i < curx; i++) {
            next[cnt++] = str[i];
            dis[cnt - 1] = abs(cur - next[cnt - 1]);
            sum[0] += abs(cur - next[cnt - 1]);
            cur = str[i];
        }

    }

    private static void Output(int[] str, int sum, int dis[], int num) {
        System.out.println("下一个磁道  移动距离");
        for (int i = 0; i < num; i++) {
            System.out.println(str[i] + "    " + dis[i]);
        }
        System.out.println("平均寻道长度：" + sum / (num * 1.0));

    }

    private static int calOne(int str[], int dis[], int cur[]) {
        int sum = 0;
        for (int i = 0, num = str.length; i < num; i++) {

            dis[i] = abs(str[i] - cur[0]);

            sum += dis[i];

            cur[0] = str[i];
        }
        return sum;
    }

    private static void SCAN() {
        int[] num = new int[1];
        int[] cur = new int[1];
        int[] str = new int[1000];
        int[] dis = new int[1000];
        int[] next = new int[1000];
        Input(num, str, cur);
        int[] sum = new int[1];
        calThree(num[0], str, cur[0], next, sum, dis);
        Output(str, sum[0], dis, num[0]);
    }

    private static void calThree(int num, int str[], int cur, int next[], int sum[], int dis[]) {
        for (int i = 0, len = str.length; i < len; i++) {
            if (str[i] == 0)
                str[i] = 0x3f3f3f3f;
        }
        Arrays.sort(str);
        int[] vis = new int[num];
        int curx = 0;
        int cnt = 0;
        for (int i = 0; i < num; i++) {
            if (str[i] >= cur) {
                curx = i;
                break;
            }

        }
        for (int i = curx; i < num; i++) {
            next[cnt++] = str[i];
            dis[cnt - 1] = abs(cur - next[cnt - 1]);
            sum[0] += abs(cur - next[cnt - 1]);
            cur = str[i];

        }
        for (int i = curx - 1; i >= 0; i--) {
            next[cnt++] = str[i];
            dis[cnt - 1] = abs(cur - next[cnt - 1]);
            sum[0] += abs(cur - next[cnt - 1]);
            cur = str[i];

        }
    }

    private static void SSTF() {
        int[] num = new int[1];
        int[] cur = new int[1];
        int[] str = new int[1000];
        int[] dis = new int[1000];
        int[] next = new int[1000];
        Input(num, str, cur);
        int[] sum = new int[1];
        calTwo(num[0], str, cur[0], next, sum, dis);
        Output(next, sum[0], dis, num[0]);
    }

    private static void calTwo(int num, int[] str, int cur, int next[], int[] sum, int[] dis) {
        int[] vis = new int[num];
        int curx = cur;
        int cnt = 0;
        while (true) {
            int len = 0x3f3f3f3f;
            int pos = -1;
            for (int i = 0; i < num; i++) {
                if (abs(str[i] - curx) < len && vis[i] == 0) {
                    len = abs(str[i] - curx);
                    pos = i;

                }
            }
            if (pos == -1)
                return;
            vis[pos] = 1;
            dis[cnt] = abs(str[pos] - curx);
            next[cnt++] = str[pos];
            sum[0] += dis[cnt - 1];
            curx = str[pos];
        }
    }

    private static int abs(int i) {
        return i > -i ? i : -i;
    }

    private static void FCFS() {
        int[] num = new int[1];
        int[] cur = new int[1];
        int[] str = new int[100];
        int[] dis = new int[1000];
        Input(num, str, cur);

        int sum = calOne(str, dis, cur);
        System.out.println(num);
        Output(str, sum, dis, num[0]);

    }

}