操作系统调度算法

实验目的：

1.理解操作系统进程管理中心进行进程调度的过程和编程方法，创建进程控制块PCB。

2.理解进程的状态及变化，动态显示每个进程的当前状态及进程的调度情况。掌握几种调度算法。理解几种进程调度的方式，用代码将几种进程调度的方式表现出来

实验内容：

1. 先来先服务：按照进程提交给系统的先后次序来进行调度。
2. 短作业优先：按照进程所要求的运行时间来衡量。
3. 时间片轮换：根据先来先服务排序，以一个时间片尾单位，依次执行不同的进程。
4. 响应比高者优先调度算法：为每个作业设置一个优先权（响应比），调度之前先计算各作业的优先权，优先权高者优先调度。

RP（相应比）=作业周转时间/作业运行时间=1+作业等待时间/作业运行时间

整个程序的大致流程

 

 

先来先服务算法流程图

 

 

短作业优先算法流程图

 

 

轮转调度算法流程图 

 

 

高响应比算法流程图 

 

 

public class FCFS {
    public static void fcfs(Process[] processes){
        float time = processes[0].getArriveTime();
        float turn = 0;
        float powerturn = 0;
        for (int i = 0; i < processes.length; i++) {
            processes[i].setStartTime(time);
            processes[i].setFinishTime(processes[i].getRunningTime() + time);
            processes[i].setTurnTime(processes[i].getFinishTime() - processes[i].getArriveTime());
            processes[i].setPowerTurnTime(processes[i].getTurnTime() / processes[i].getRunningTime());
            time += processes[i].getRunningTime();
            turn  += processes[i].getTurnTime();
            powerturn += processes[i].getPowerTurnTime();
            System.out.println(processes[i].toString());
        }
        processes[0].setAverageTurnTime(turn / (float)processes.length);
        processes[0].setAveragePowerTurnTime(powerturn / (float)processes.length);
        System.out.println("平均周转时间：" + processes[0].getAverageTurnTime());
        System.out.println("平均带权周转时间：" + processes[0].getAveragePowerTurnTime());
    }
}

 

public class HRRN{
    public static void hrrn(Process[] processes){
        float time = processes[0].getArriveTime();
        float turn = 0;
        float powerturn = 0;
        //进程响应比
        ArrayList<Float> radio = new ArrayList<>();
        ArrayList<Integer> index = new ArrayList<>();
        ArrayList<Process> a = new ArrayList<>();
        Collections.addAll(a, processes);
        for (int i = 1; i < processes.length; i++){
            Process t = a.get(0);
            a.remove(0);
            ResponseRatio(radio,a, processes, t);
            System.out.print("第" + i + "次相应时间为：");
            for (float f:radio) {
                System.out.print(f + " ");
            }
            System.out.println();
            index.add(sort(radio));
            radio.clear();
            swap(a,0,index.get(index.size()-1));
        }
        ssort(processes, index);
        for (int i = 0; i < processes.length; i++) {
            processes[i].setStartTime(time);
            processes[i].setFinishTime(processes[i].getRunningTime() + time);
            processes[i].setTurnTime(processes[i].getFinishTime() - processes[i].getArriveTime());
            processes[i].setPowerTurnTime(processes[i].getTurnTime() / processes[i].getRunningTime());
            time += processes[i].getRunningTime();
            turn  += processes[i].getTurnTime();
            powerturn += processes[i].getPowerTurnTime();
            System.out.println(processes[i].toString());
        }
        processes[0].setAverageTurnTime(turn / (float)processes.length);
        processes[0].setAveragePowerTurnTime(powerturn / (float)processes.length);
        System.out.println("平均周转时间：" + processes[0].getAverageTurnTime());
        System.out.println("平均带权周转时间：" + processes[0].getAveragePowerTurnTime());
    }

    private static void ssort(Process[] processes, ArrayList<Integer> index) {
        Process tmp = null;
        for (int i = 1; i < processes.length; i++){
            for (int j = 0; j < index.size(); j++) {
                if (processes[i].getPeocessName() == index.get(j)) {
                    tmp = processes[i];
                    processes[i] = processes[j+2];
                    processes[j+2] = tmp;
                }
            }
        }
    }

    private static void swap(ArrayList<Process> a, int i, Integer integer) {
        Process t;
        t = a.get(i);
        a.set(0,a.get(integer));
    }

    private static int sort(ArrayList<Float> radio) {
        int x = 0;
        float max = radio.get(0);
        for (int i = 0; i < radio.size(); i++){
            if (max < radio.get(i)){
                max = radio.get(i);
                x = i;
            }
        }
        return x;
    }

    private static void ResponseRatio(ArrayList<Float> radio, ArrayList<Process> a, Process[] processes, Process t) {
        float waitTime = 0;
        float w;
        for (int i = 0; i < a.size(); i ++){
            waitTime = t.getArriveTime() + t.getRunningTime();
            w = waitTime - a.get(i).getArriveTime();
            radio.add(1 + (w / a.get(i).getRunningTime()));
        }
    }
}

public class Process{
    //进程名
    private float PeocessName;
    //到达时间
    private float ArriveTime;
    //运行时间
    private float RunningTime;
    //开始时间
    private float StartTime;
    //完成时间
    private float FinishTime;
    //周转时间
    private float TurnTime;
    //带权周转时间
    private float PowerTurnTime;
    //平均周转时间
    private float AverageTurnTime;
    //平均带权周转时间
    private float AveragePowerTurnTime;

    public float getPrior() {
        return prior;
    }

    public void setPrior(float prior) {
        this.prior = prior;
    }

    private float prior;

    public float getPeocessName() {
        return PeocessName;
    }

    public void setPeocessName(float peocessName) {
        PeocessName = peocessName;
    }

    public float getArriveTime() {
        return ArriveTime;
    }

    public void setArriveTime(float arriveTime) {
        ArriveTime = arriveTime;
    }

    public float getRunningTime() {
        return RunningTime;
    }

    public void setRunningTime(float runningTime) {
        RunningTime = runningTime;
    }

    public float getStartTime() {
        return StartTime;
    }

    public void setStartTime(float startTime) {
        StartTime = startTime;
    }

    public float getFinishTime() {
        return FinishTime;
    }

    public void setFinishTime(float finishTime) {
        FinishTime = finishTime;
    }

    public float getTurnTime() {
        return TurnTime;
    }

    public void setTurnTime(float turnTime) {
        TurnTime = turnTime;
    }

    public float getPowerTurnTime() {
        return PowerTurnTime;
    }

    public void setPowerTurnTime(float powerTurnTime) {
        PowerTurnTime = powerTurnTime;
    }

    public float getAverageTurnTime() {
        return AverageTurnTime;
    }

    public void setAverageTurnTime(float averageTurnTime) {
        AverageTurnTime = averageTurnTime;
    }

    public float getAveragePowerTurnTime() {
        return AveragePowerTurnTime;
    }

    public void setAveragePowerTurnTime(float averagePowerTurnTime) {
        AveragePowerTurnTime = averagePowerTurnTime;
    }

    @Override
    public String toString(){
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("进程:").append(PeocessName).append(" ")
                .append("到达时间:").append(ArriveTime).append(" ")
                .append("运行时间:").append(RunningTime).append(" ")
                .append("开始时间:").append(StartTime).append(" ")
                .append("完成时间:").append(FinishTime).append(" ")
                .append("周转时间:").append(TurnTime).append(" ")
                .append("带权周转时间:").append(PowerTurnTime).append(" ");
        return stringBuilder.toString();
    }

}

public class RR {
    private static int slice;
    private static float time;
    private static float turn = 0, powerturn = 0;
    private static float[] flag, run;
    public static void rr(Process[] processes) {
        Scanner scanner = new Scanner(System.in);
        //当前时间
        time = processes[0].getArriveTime();
        //设置时间片大小
        System.out.print("请输入时间片大小：");
        slice = scanner.nextInt();
        sort(processes);
        for (int i = 0; i < processes.length; i++){
                processes[i].setStartTime(flag[i]);
                processes[i].setRunningTime(run[i]);
                processes[i].setTurnTime(processes[i].getFinishTime() - processes[i].getArriveTime());
                processes[i].setPowerTurnTime(processes[i].getTurnTime() / processes[i].getRunningTime());
                turn  += processes[i].getTurnTime();
                powerturn += processes[i].getPowerTurnTime();
            System.out.println(processes[i].toString());
        }
        processes[0].setAverageTurnTime(turn / (float)processes.length);
        processes[0].setAveragePowerTurnTime(powerturn / (float)processes.length);
        System.out.println("平均周转时间：" + processes[0].getAverageTurnTime());
        System.out.println("平均带权周转时间：" + processes[0].getAveragePowerTurnTime());
    }

    private static void sort(Process[] processes) {
        int i = 0;
        int k = 1;
        flag = new float[processes.length];
        run = new float[processes.length];
        Process[] processes1 = new Process[processes.length];
        for (int j = 0; j < processes1.length; j++){
            processes1[j] = processes[j];
            run[j] = processes[j].getRunningTime();
        }
        //就绪队列
        ArrayList<Process> a = new ArrayList<>();
        a.add(processes1[0]);
        while (!a.isEmpty()) {
            Process tmp = a.get(0);
            a.remove(0);
            if (k < processes.length) {
                if (processes[i].getArriveTime() <= Math.min(slice, processes[i].getRunningTime())) {
                    a.add(processes1[k]);
                }
                flag[k] = time + a.size();
                k++;
            }
            if (tmp.getRunningTime() > slice) {
                tmp.setRunningTime(tmp.getRunningTime() - slice);
                time += slice;
                a.add(tmp);
            } else {
                time += slice;
                tmp.setFinishTime(time);
                processes[(int) tmp.getPeocessName()].setFinishTime(tmp.getFinishTime());
            }
        }
    }
}

public class SchedulingAlgorithm {

    public static void main (String[] args){
        SchedulingAlgorithm s = new SchedulingAlgorithm();
        s.schedulingalgorithm();
        System.out.println(s.toString());
    }

    public void schedulingalgorithm() {
        Scanner scanner = new Scanner(System.in);

        //初始化进程
        System.out.println("请输入进程数目：");
        int size = scanner.nextInt();//进程数
        Process[] processes = new Process[size];//进程存储
        for (int i = 0; i < size; i++) {
            Process process = new Process();
            System.out.println("请输入第" + (i + 1) + "个进程的名字 提交时间 运行时间");
            process.setPeocessName(scanner.nextFloat());
            process.setArriveTime(scanner.nextInt());
            process.setRunningTime(scanner.nextInt());
            processes[i] = process;
        }

        while (true) {
            System.out.println("1.FCFS");
            System.out.println("2.SJF");
            System.out.println("3.RR");
            System.out.println("4.HRRN");
            System.out.println("5.退出");
            int chioce;
            System.out.print("请选择算法：");
            chioce = scanner.nextInt();
            while (chioce <= 0 || chioce > 5) {
                System.out.println("无此选项请重新输入:");
                chioce = scanner.nextInt();
            }
            if (chioce == 5) {
                System.exit(0);
            }
            switch (chioce) {
                case 1:
                    FCFS.fcfs(processes);
                    break;
                case 2:
                    SJF.sjf(processes);
                    break;
                case 3:
                    RR.rr(processes);
                    break;
                case 4:
                    HRRN.hrrn(processes);
                    break;
            }
        }
    }
}

public class SJF {

    public static void sjf(Process[] processes){
        float time = processes[0].getArriveTime();
        float turn = 0;
        float powerturn = 0;
        sort(processes);
        for (int i = 0; i < processes.length; i++) {
            processes[i].setStartTime(time);
            processes[i].setFinishTime(processes[i].getRunningTime()+time);
            processes[i].setTurnTime(processes[i].getFinishTime() - processes[i].getArriveTime());
            processes[i].setPowerTurnTime(processes[i].getTurnTime() / processes[i].getRunningTime());
            time += processes[i].getRunningTime();
            turn  += processes[i].getTurnTime();
            powerturn += processes[i].getPowerTurnTime();
            System.out.println(processes[i].toString());
        }
        processes[0].setAverageTurnTime(turn / (float)processes.length);
        processes[0].setAveragePowerTurnTime(powerturn / (float)processes.length);
        System.out.println("平均周转时间：" + processes[0].getAverageTurnTime());
        System.out.println("平均带权周转时间：" + processes[0].getAveragePowerTurnTime());
        newsort(processes);
    }

    private static void newsort(Process[] processes) {
        for (int i = 1; i < processes.length; i++){
            int l = (int) processes[i].getPeocessName();
            Process t;
            t = processes[l];
            processes[l] = processes[i];
            processes[i] = t;
        }
    }


    public static void sort(Process[] processes){
        Process tmp = null;
        for (int i = 1; i < processes.length-1; i++){
            for (int j = 1; j < processes.length-i; j++){
                if (processes[j].getRunningTime() > processes[j+1].getRunningTime()){
                    tmp = processes[j];
                    processes[j] = processes[j+1];
                    processes[j+1] = tmp;
                }
            }
        }
    }
}