HRRN RR Java 代码实现

 HRRNClass.java

public class HRRNClass {
    //    定义HRRN类
//    生成无参构造方法，带参构造方法
//    生成对应的get、Set方法
//    重写toString方法
    private String processId; //进程编号
    private int arrivalTime;//到达时间
    private int cpuBurst;//服务时间
    private int startTime;//开始时间
    private int finishTime;//结束时间
    private int turnaroundTime;//周转时间
    private double cTurnaroundTime;//带权周转时间
    private int waitingTime;//等待时间
    private double rate;

    //带全部参数的构造方法

    public HRRNClass(String processId, int arrivalTime, int cpuBurst, int startTime, int finishTime, int turnaroundTime, double cTurnaroundTime, int waitingTime) {
        this.processId = processId;
        this.arrivalTime = arrivalTime;
        this.cpuBurst = cpuBurst;
        this.startTime = startTime;
        this.finishTime = finishTime;
        this.turnaroundTime = turnaroundTime;
        this.cTurnaroundTime = cTurnaroundTime;
        this.waitingTime = waitingTime;

    }


    //    无参构造方法
    public HRRNClass() {
    }

    //   带三个参数的构造方法
    public HRRNClass(String processId, int arrivalTime, int cpuBurst) {
        this.processId = processId;
        this.arrivalTime = arrivalTime;
        this.cpuBurst = cpuBurst;
    }

    //    get、Set方法

    public String getProcessId() {
        return processId;
    }

    public void setProcessId(String processId) {
        this.processId = processId;
    }

    public int getArrivalTime() {
        return arrivalTime;
    }

    public void setArrivalTime(int arrivalTime) {
        this.arrivalTime = arrivalTime;
    }

    public int getCpuBurst() {
        return cpuBurst;
    }

    public void setCpuBurst(int cpuBurst) {
        this.cpuBurst = cpuBurst;
    }


    public int getStartTime() {
        return startTime;
    }

    public void setStartTime(int startTime) {
        this.startTime = startTime;
    }

    public int getFinishTime() {
        return finishTime;
    }

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

    public int getTurnaroundTime() {
        return turnaroundTime;
    }

    public void setTurnaroundTime(int turnaroundTime) {
        this.turnaroundTime = turnaroundTime;
    }

    public double getcTurnaroundTime() {
        return cTurnaroundTime;
    }

    public void setcTurnaroundTime(double cTurnaroundTime) {
        this.cTurnaroundTime = cTurnaroundTime;
    }

    public int getWaitingTime() {
        return waitingTime;
    }

    public void setWaitingTime(int waitingTime) {
        this.waitingTime = waitingTime;
    }

    public double getRate() {
        return rate;
    }

    public void setRate(double rate) {
        this.rate = rate;
    }
//    重写toString方法


    @Override
    public String toString() {
        return "HRRNClass{" +
                "processId='" + processId + '\'' +
                ", arrivalTime=" + arrivalTime +
                ", cpuBurst=" + cpuBurst +
                ", startTime=" + startTime +
                ", finishTime=" + finishTime +
                ", turnaroundTime=" + turnaroundTime +
                ", cTurnaroundTime=" + cTurnaroundTime +
                ", waitingTime=" + waitingTime +
                '}';
    }
}

 HRRNDemo.java

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;


public class HRRNDemo {
    //    定义测试类
    public static void main(String[] args) throws IOException {
//      Read data from the processInfo.txt and store it in the ArrayList collection
        BufferedReader br = new BufferedReader(new FileReader("HRRN\\src\\processInfo.txt"));

        String line;

        ArrayList<HRRNClass> processes = new ArrayList<>();
//       Reads a row of data, slices the data, initializes the object with a constructor with three parameters,
//       and stores the object into the ArrayList collection
        while ((line = br.readLine()) != null) {

            String[] data = line.split(",");//以逗号对数据进行切分
            String processId = data[0];
            int arrivalTime = Integer.parseInt(data[1]);//注意切分得到的每个数据对象是String类型，需转换成Int对应的包装类类型Integer类型

            int cpuBurst = Integer.parseInt(data[2]);//同上
            processes.add(new HRRNClass(processId, arrivalTime, cpuBurst));

        }
//        The enhanced for loop is used to traverse the ArrayList data and print the input data information
        System.out.println("输入信息：");
        for (HRRNClass process : processes) {
            System.out.println(process);
        }
//        Line breaks
        System.out.println("\n");

        //记录最先到达就绪队列进程
        int index = 0;
        for (int i = 1; i < processes.size(); i++) {
            if (processes.get(i).getArrivalTime() < processes.get(index).getArrivalTime()) {
                index = i;
            }
        }

        processes.get(index).setStartTime(0);
        processes.get(index).setFinishTime(processes.get(index).getStartTime() + processes.get(index).getCpuBurst());
        processes.get(index).setTurnaroundTime(processes.get(index).getFinishTime() - processes.get(index).getArrivalTime());
        processes.get(index).setcTurnaroundTime(processes.get(index).getTurnaroundTime() * 1.0 / processes.get(index).getCpuBurst());
        HRRNClass aClass = processes.get(index);
        int finishTime = processes.get(index).getFinishTime();
        System.out.println(aClass);
        processes.remove(index);


        while (true) {
            //计算就绪队列中各进程相应比
            for (int i = 0; i < processes.size(); i++) {
                HRRNClass hrrnClass = processes.get(i);
                hrrnClass.setRate((finishTime - hrrnClass.getArrivalTime() + hrrnClass.getCpuBurst()) * 1.0 / hrrnClass.getCpuBurst());
            }

            //调用工具类Collections工具类对就绪队列中各个进程按其相应比从高到低排序
            Collections.sort(processes, new Comparator<HRRNClass>() {
                @Override
                public int compare(HRRNClass o1, HRRNClass o2) {
                    return Double.compare(o2.getRate(), o1.getRate());
                }
            });

            //得到就绪队列中最高响应比的进程，分配处理机资源，优先调度
            HRRNClass hrrnClass = processes.get(0);
            processes.get(0).setStartTime(finishTime);
            processes.get(0).setFinishTime(processes.get(0).getStartTime() + processes.get(0).getCpuBurst());
            processes.get(0).setTurnaroundTime(processes.get(0).getFinishTime() - processes.get(0).getArrivalTime());
            processes.get(0).setcTurnaroundTime(processes.get(0).getTurnaroundTime() * 1.0 / processes.get(0).getCpuBurst());
            processes.get(0).setWaitingTime(processes.get(0).getStartTime() - processes.get(0).getArrivalTime());

            System.out.println(hrrnClass);
            //更改当前完成时间
            finishTime = processes.get(0).getFinishTime();
            processes.remove(0);

            if (processes.size() == 0) {
                break;
            }
        }

    }

}

processInfo.txt

p1,0,3
p3,2,1
p2,1,6
p4,3,5

 Process.java

//进程
class Process {
    private String name;
    private int arrivalTime; //到达时间
    private int cpuBurst; //服务时间
    private int remainServiceTime; //还需要服务的时间
    private int finishTime; //完成时间
    private int turnaroundTime; //周转时间
    private double cTurnaroundTime; //带权周转时间

    public int getRemainServiceTime() {
        return remainServiceTime;
    }

    public void setRemainServiceTime(int remainServiceTime) {
        this.remainServiceTime = remainServiceTime;
    }

    public Process(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getArrivalTime() {
        return arrivalTime;
    }

    public void setArrivalTime(int arrivalTime) {
        this.arrivalTime = arrivalTime;
    }

    public int getCpuBurst() {
        return cpuBurst;
    }

    public void setCpuBurst(int cpuBurst) {
        this.cpuBurst = cpuBurst;
    }

    public int getFinishTime() {
        return finishTime;
    }

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

    public int getTurnaroundTime() {
        return turnaroundTime;
    }

    public void setTurnaroundTime(int turnaroundTime) {
        this.turnaroundTime = turnaroundTime;
    }

    public double getcTurnaroundTime() {
        return cTurnaroundTime;
    }

    public void setcTurnaroundTime(double cTurnaroundTime) {
        this.cTurnaroundTime = cTurnaroundTime;
    }
}

 RRDemo.java

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.concurrent.LinkedBlockingQueue;

public class RRDemo {
    private final int processCount; //进程数
    private final Queue<Process> readQueue; //就绪队列
    private final Queue<Process> unreachedQueue; //未到currTime队列
    private final int timeSlice; //时间片

    private final Queue<Process> executeQueue; //执行完毕的进程队列
    private double TotalWholeTime = 0.0;
    private double TotalWeightWholeTime = 0.0;

    private RRDemo(int processCount, Queue<Process> processQueue, int timeSlice) {
        this.processCount = processCount;
        this.unreachedQueue = processQueue;
        readQueue = new LinkedBlockingQueue<>();
        this.timeSlice = timeSlice;
        executeQueue = new LinkedList<>();
    }

    /**
     * RR 算法实现
     */
    public void RRAlgorithm() {
        readQueue.add(unreachedQueue.poll());
        Process currProcess = readQueue.poll();
        //第一个进程执行
        assert currProcess != null;
        int currTime = executeProcess(currProcess, 0);

        while (!readQueue.isEmpty() || !unreachedQueue.isEmpty()) {
            //把所有“到达时间”达到的进程加入运行队列头部
            while (!unreachedQueue.isEmpty()) {
                if (unreachedQueue.peek().getArrivalTime() <= currTime) {
                    readQueue.add(unreachedQueue.poll());
                } else {
                    break;
                }
            }

            if (currProcess.getRemainServiceTime() > 0) readQueue.add(currProcess);
            //运行队列不为空时
            if (!readQueue.isEmpty()) {
                currProcess = readQueue.poll();
                currTime = executeProcess(currProcess, currTime);
            } else {
                //当前没有进程执行，但还有进程为到达，时间直接跳转到到达时间
                currTime = unreachedQueue.peek().getArrivalTime();
            }
        }
    }

    private int executeProcess(Process currProcess, int currTime) {
        if (currProcess.getRemainServiceTime() - timeSlice <= 0) {
            //当前进程在这个时间片内能执行完毕
            showExecuteMessage(currTime, currTime += currProcess.getRemainServiceTime(), currProcess.getName());
            currProcess.setFinishTime(currTime);
            currProcess.setRemainServiceTime(0);
            //对周转时间等进行计算
            calculateWholeTime(currProcess);
            calculateWeightWholeTime(currProcess);
            TotalWholeTime += currProcess.getTurnaroundTime();
            TotalWeightWholeTime += currProcess.getcTurnaroundTime();
            executeQueue.add(currProcess);
        } else {
            //不能执行完毕
            showExecuteMessage(currTime, currTime += timeSlice, currProcess.getName());
            currProcess.setRemainServiceTime(currProcess.getRemainServiceTime() - timeSlice);
        }
        return currTime;
    }

    /**
     * 计算周转时间
     *
     */
    private void calculateWholeTime(Process process) {
        process.setTurnaroundTime(process.getFinishTime() - process.getArrivalTime());
    }

    /**
     * 计算带权周转时间
     *
     */
    private void calculateWeightWholeTime(Process process) {
        process.setcTurnaroundTime(process.getTurnaroundTime() / (double) process.getCpuBurst());
    }

    private void showExecuteMessage(int startTime, int endTime, String name) {
        System.out.println(startTime + "～" + endTime + "：【进程" + name + "】运行");
    }

    public void showResult() {
        System.out.print("进程名\t");
        System.out.print("周转时间\t");
        System.out.println("带权周转时间\t");
        Process process;
        while (!executeQueue.isEmpty()) {
            process = executeQueue.poll();
            System.out.print("进程" + process.getName() + "\t");
            System.out.print("\t" + process.getTurnaroundTime() + "\t");
            System.out.println("\t" + process.getcTurnaroundTime() + "\t");
        }
        System.out.println("平均周转时间：" + TotalWholeTime / (double) processCount);
        System.out.println("平均带权周转时间：" + TotalWeightWholeTime / (double) processCount);
    }

    public static void printAll(Queue<Process> queue) {
        System.out.print("进程名\t");
        System.out.print("到达时间\t");
        System.out.println("服务时间\t");
        Process process = null;
        while (!queue.isEmpty()) {
            process = queue.poll();
            System.out.print("进程" + process.getName() + "\t");
            System.out.print("\t" + process.getArrivalTime() + "\t");
            System.out.println("\t" + process.getCpuBurst() + "\t");
        }
    }

    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        Queue<Process> queue = new LinkedBlockingQueue<>();
//      Read data from the processInfo.txt
        BufferedReader br = new BufferedReader(new FileReader("RR\\src\\processInfo.txt"));
        String line;
//       Reads a row of data, slices the data, initializes the object
        while ((line = br.readLine()) != null) {
            String[] data = line.split(",");//以逗号对数据进行切分
            String name = data[0];
            int arrivalTime = Integer.parseInt(data[1]);//注意切分得到的每个数据对象是String类型，需转换成Int对应的包装类类型Integer类型
            int cpuBurst = Integer.parseInt(data[2]);//同上
            Process process = new Process(name);
            process.setArrivalTime(arrivalTime);
            process.setCpuBurst(cpuBurst);
            process.setRemainServiceTime(cpuBurst);
            queue.add(process);
        }

        int processCount = queue.size();

        System.out.println("输入时间片大小");
        int timeSlice = sc.nextInt();

        RRDemo rr = new RRDemo(processCount, queue, timeSlice);

        System.err.println("*******************进程情况*****************");
        Thread.sleep(1000);
        printAll(new LinkedBlockingQueue<>(queue));
        Thread.sleep(1000);

        System.err.println("******************运行过程*****************");
        Thread.sleep(1000);
        rr.RRAlgorithm();
        Thread.sleep(1000);

        System.err.println("*******************运行结果*****************");
        Thread.sleep(1000);
        rr.showResult();
    }

}