操作系统：高响应比优先调度算法（HRRN）Java代码实现

一、算法思想：

        高响应比优先调度算法（HRRN）是一种对CPU响应比的分配的一种算法。HRRN是介于FCFS（先来先服务算法）与SJF（短作业优先算法）之间的折中算法，既考虑作业等待时间又考虑作业运行时间，既照顾短作业又不使长作业等待时间过长，改进了调度性能。

 二、实现代码：

package Package8;

import java.util.Scanner;

/**
 * 高响应比优先调度
 */
public class HRRN {

    public static void main(String[] args) {

        PCB[] a = new PCB[10];

        // input方法用于输入进程信息，返回输入进程的总数
        int k = input(a);

        // 输出初始作业状态
        System.out.println("初始作业状态：");
        // 遍历输出数组
        output(a, k);


        // 找出最早到达的进程,优先调度
        PCB min = new PCB();
        min = a[0];
        int m = 0; // 用于记录最早到达进程的id（下标）
        for (int i = 0; i < k; i++) {

            if (a[i].getArriveTime() < min.getArriveTime()){
                min = a[i];
                m = i;
            } else if(a[i].getArriveTime() == min.getArriveTime() && a[i].getServiceTime() < min.getServiceTime()){
                min = a[i];
                m = i;
            }
        }
        PCB temp;
        temp = a[0];
        a[0] = min;
        a[m] = temp;


        System.out.println("调度过程：");
        // currentTime 用于记录当前时间（最后一个已经调度的作业的完成时间）
        double currentTime = 0;
        // 当该进程最早到达时，直接调度
        a[0].setCondition(1); // 调度进程，将进程状态改为运行
        a[0].setFinishTime(a[0].getArriveTime() + a[0].getServiceTime());
        a[0].setCyclingTime(a[0].getFinishTime() - a[0].getArriveTime());
        // 将结果保留两位小数
        double time = a[0].getCyclingTime() / a[0].getServiceTime();
        a[0].setFloat_Wi(Double.parseDouble(String .format("%.2f", time)));
        output(a,k); // 遍历数组
        a[0].setCondition(2); // 进程调度完毕，将进程状态改为完成
        // 记录当前时间
        currentTime = a[0].getFinishTime();

        for (int i = 1; i < k; i++) {
            for (int j = i; j < k; j++) {

                    if (currentTime - a[j].getArriveTime() < 0){
                        a[j].setWaitTime(0);
                    } else {
                        a[j].setWaitTime(currentTime - a[j].getArriveTime());
                    }
                    a[j].setDibs((a[j].getWaitTime()/a[j].getServiceTime()) + 1);

            }


            // 找出优先权最大的进程，放到第i个位置，直接调度
            PCB max;
            max = a[0]; // a[0]的优先级默认为0
            int n = 0; // 用于当前优先权最大进程的id（下标）
            for (int x = i; x < k; x++) {
                if (a[x].getDibs() > max.getDibs()){
                    max = a[x];
                    n = x;
                } else if (a[x].getDibs() == max.getDibs() && a[x].getArriveTime() < max.getArriveTime()){
                    max = a[x];
                    n = x;
                }
            }
            temp = a[i];
            a[i] = max;
            a[n] = temp;

            // 调度第i个进程
            a[i].setCondition(1);
            output(a,k);
            if (a[i].getArriveTime() > a[i - 1].getFinishTime()){
                a[i].setFinishTime(a[i].getArriveTime() + a[i].getServiceTime());

            } else{

                a[i].setFinishTime(a[i - 1].getFinishTime() + a[i].getServiceTime());
            }
            a[i].setCyclingTime(a[i].getFinishTime() - a[i].getArriveTime());

            // 将结果保留两位小数
            time = a[i].getCyclingTime() / a[i].getServiceTime();
            a[i].setFloat_Wi(Double.parseDouble(String .format("%.2f", time)));
            a[i].setCondition(2);
            // 记录当前时间
            currentTime = a[i].getFinishTime();


        // 一轮循环结束，进入下一轮循环
        }

        // 遍历输出数组
        System.out.println("调度后作业状态：");
        output(a, k);

    }

    /**
     * 该方法用于遍历输出数组
     * @param a
     * @param k
     */
    public static void output(PCB[] a, int k){
        for (int i = 0; i < k; i++) {
            System.out.println(a[i]);
            if (i == k - 1){
                System.out.println();
            }
        }
    }

    /**
     * 该方法用于输入进程信息
     * @param a
     * @return 输入进程的个数
     */
    public static int input(PCB[] a){

        Scanner scanner = new Scanner(System.in);

        int k = 0; // 初始化,k记录总进程数
        System.out.println("请一次输入两个整数，之间用空格隔开,输入负数结束输入");

        // 重复输入进程信息
        while (true){
            System.out.printf("请输入第%d进程到达时间、服务时间：", k);
            // 将进程id设置为k
            double arriveTime = scanner.nextDouble();
            if (arriveTime < 0){
                System.out.println("输入结束");
                break;
            }
            double serviceTime = scanner.nextDouble();
            a[k] = new PCB(k,arriveTime, serviceTime); // 利用构造方法初始化数据
            k ++;
            if (serviceTime < 0){
                System.out.println("输入结束");
                break;
            }
        }
        scanner.close(); // 释放scanner

        return k;
    }


    public static class PCB implements Package8.PCB {

        private int id;
        private double arriveTime; // 到达时间
        private double serviceTime; // 服务时间
        private double finishTime; // 完成时间
        private double cyclingTime; // 周转时间
        private double float_Wi; // 带权周转时间
        private double waitTime; // 等待时间
        private double dibs; // 优先权
        private int condition; // 进程状态，0表示等待，1表示运行，2表示完成

        public int getCondition() {
            return condition;
        }

        public void setCondition(int condition) {
            this.condition = condition;
        }

        public double getWaitTime() {
            return waitTime;
        }

        public void setWaitTime(double waitTime) {
            this.waitTime = waitTime;
        }

        public double getDibs() {
            return dibs;
        }

        public void setDibs(double dibs) {
            this.dibs = dibs;
        }

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public double getArriveTime() {
            return arriveTime;
        }

        public void setArriveTime(double arriveTime) {
            this.arriveTime = arriveTime;
        }

        public double getServiceTime() {
            return serviceTime;
        }

        public void setServiceTime(double serviceTime) {
            this.serviceTime = serviceTime;
        }

        public double getFinishTime() {
            return finishTime;
        }

        public void setFinishTime(double finishTime) {
            this.finishTime = finishTime;
        }

        public double getCyclingTime() {
            return cyclingTime;
        }

        public void setCyclingTime(double cyclingTime) {
            this.cyclingTime = cyclingTime;
        }

        public double getFloat_Wi() {
            return float_Wi;
        }

        public void setFloat_Wi(double float_Wi) {
            this.float_Wi = float_Wi;
        }

        public PCB() {
        }

        public PCB(int id, double arriveTime, double serviceTime) {
            this.id = id;
            this.arriveTime = arriveTime;
            this.serviceTime = serviceTime;
        }

        @Override
        public String toString() {
            String condition1;
            if (condition == 2){
                condition1 = "完成";
                return "进程信息：" +
                        "id=" + id +
                        ", 到达时间=" + arriveTime +
                        ", 服务时间=" + serviceTime +
                        ", 完成时间=" + finishTime +
                        ", 周转时间=" + cyclingTime +
                        ", 带权周转时间=" + float_Wi +
                        ", 进程状态：" + condition1;
            } else {
                if (condition == 1){
                    condition1 = "运行";
                } else {
                    condition1 = "等待";
                }

                return "进程信息：" +
                        "id=" + id +
                        ", 到达时间=" + arriveTime +
                        ", 服务时间=" + serviceTime +
                        ", 完成时间=" + finishTime +
                        ", 周转时间=" + cyclingTime +
                        ", 带权周转时间=" + float_Wi +
                        ", 进程状态：" + condition1 +
                        ", 进程优先权：" + dibs;
            }
        }

    }
}

三、运行结果：