Java实现作业调度算法

一、原理及说明

1.高响应比算法

动态优先权是指在创建进程时所赋予的优先权，是可以随进程的推进或随其等待时间的增加而改变的，以便获得更好的调度性能。引入动态优先权，并使作业的优先权随其等待时间的增长，其优先权以速率a提高。优先权的变化规律可描述为：

优先权=（等待时间+要求服务时间）/要求服务时间。

2.时间片轮转调度算法

分时操作系统中多采用时间片轮转法；把CPU分配给队首进程，它执行一个时间片；时间片完时排在就绪队列的末尾，重新把处理机分配给就绪队列中新队首进程，也执行一个时间片；就绪队列中的所有进程在给定时间内，均可获得一个时间片的CPU时间。

 例题:

1. 高响应比优先算法

假如系统中现有3个作业，分别为A、B、C，它们的作业大小、需要磁带机数、需要打印机数，在外存上等待的时间以及估计需要执行时间分别是：

A  5  2  1  3  10

B  3  3  2  4  6

C  7  1  2  2  14

按高响应比优先算法，假如要选一个作业，你认为选择哪个作业进行调度？

代码:

HighResponseRatioScheduling类

import java.util.Scanner;

class Job {
    String name;
    int size;
    int tapeCount;
    int printerCount;
    int waitTime;
    int runTime;

    Job(String name, int size, int tapeCount, int printerCount, int waitTime, int runTime) {
        this.name = name;
        this.size = size;
        this.tapeCount = tapeCount;
        this.printerCount = printerCount;
        this.waitTime = waitTime;
        this.runTime = runTime;
    }
}

public class HighResponseRatioScheduling {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 输入作业A的相关数据
        System.out.println("请输入作业A的名称：");
        String nameA = scanner.next();
        System.out.println("请输入作业A的大小：");
        int sizeA = scanner.nextInt();
        System.out.println("请输入作业A需要的磁带机数：");
        int tapeCountA = scanner.nextInt();
        System.out.println("请输入作业A需要的打印机数：");
        int printerCountA = scanner.nextInt();
        System.out.println("请输入作业A在外存上等待的时间：");
        int waitTimeA = scanner.nextInt();
        System.out.println("请输入作业A估计需要执行时间：");
        int runTimeA = scanner.nextInt();

        // 输入作业B的相关数据
        System.out.println("请输入作业B的名称：");
        String nameB = scanner.next();
        System.out.println("请输入作业B的大小：");
        int sizeB = scanner.nextInt();
        System.out.println("请输入作业B需要的磁带机数：");
        int tapeCountB = scanner.nextInt();
        System.out.println("请输入作业B需要的打印机数：");
        int printerCountB = scanner.nextInt();
        System.out.println("请输入作业B在外存上等待的时间：");
        int waitTimeB = scanner.nextInt();
        System.out.println("请输入作业B估计需要执行时间：");
        int runTimeB = scanner.nextInt();

        // 输入作业C的相关数据
        System.out.println("请输入作业C的名称：");
        String nameC = scanner.next();
        System.out.println("请输入作业C的大小：");
        int sizeC = scanner.nextInt();
        System.out.println("请输入作业C需要的磁带机数：");
        int tapeCountC = scanner.nextInt();
        System.out.println("请输入作业C需要的打印机数：");
        int printerCountC = scanner.nextInt();
        System.out.println("请输入作业C在外存上等待的时间：");
        int waitTimeC = scanner.nextInt();
        System.out.println("请输入作业C估计需要执行时间：");
        int runTimeC = scanner.nextInt();

        // 计算高响应比优先算法的优先级及调度顺序
        double responseRatioA = (double) (waitTimeA + runTimeA) / runTimeA;
        double responseRatioB = (double) (waitTimeB + runTimeB) / runTimeB;
        double responseRatioC = (double) (waitTimeC + runTimeC) / runTimeC;

        if (responseRatioA > responseRatioB && responseRatioA > responseRatioC) {
            System.out.println("选择调度作业：" + nameA);
        } else if (responseRatioB > responseRatioA && responseRatioB > responseRatioC) {
            System.out.println("选择调度作业：" + nameB);
        } else {
            System.out.println("选择调度作业：" + nameC);
        }
    }
}

2.短作业算法

代码:

ShortestJobFirst类

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;


class Job {
    String name;
    int size;
    int tapeCount;
    int printerCount;
    int waitTime;
    int executionTime;

    public Job(String name, int size, int tapeCount, int printerCount, int waitTime, int executionTime) {
        this.name = name;
        this.size = size;
        this.tapeCount = tapeCount;
        this.printerCount = printerCount;
        this.waitTime = waitTime;
        this.executionTime = executionTime;
    }

    public int getExecutionTime() {
        return executionTime;
    }
}


public class ShortestJobFirst {
    public static void main(String[] args) {
        List<Job> jobs = new ArrayList<>();
        jobs.add(new Job("A", 5, 2, 1, 3, 10));
        jobs.add(new Job("B", 3, 3, 2, 4, 6));
        jobs.add(new Job("C", 7, 1, 2, 2, 14));

        // 按作业估计执行时间排序
        Collections.sort(jobs, Comparator.comparing(Job::getExecutionTime));

        System.out.println("选择调度的程序是：" + jobs.get(0).name);
    }
}

3. 时间片轮转调度算法

现在有5个进程，它们的进程号、到达时间、运行时间分别如下：

进程号     到达时间      运行时间

1           0              4

  2           1              5

  3           2              2

  4           3              3

  5           4              2

 代码:

RoundRobinScheduling类

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

class Process {
    String name;
    int arrivalTime;
    int burstTime;
    int remainingTime;

    Process(String name, int arrivalTime, int burstTime) {
        this.name = name;
        this.arrivalTime = arrivalTime;
        this.burstTime = burstTime;
        this.remainingTime = burstTime;
    }
}

public class RoundRobinScheduling {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 创建进程队列
        Queue<Process> processQueue = new LinkedList<>();

        // 输入5个进程的相关数据
        for (int i = 1; i <= 5; i++) {
            System.out.println("请输入进程" + i + "的名称：");
            String name = scanner.next();
            System.out.println("请输入进程" + i + "的到达时间：");
            int arrivalTime = scanner.nextInt();
            System.out.println("请输入进程" + i + "的服务时间：");
            int burstTime = scanner.nextInt();

            Process process = new Process(name, arrivalTime, burstTime);
            processQueue.add(process);
        }

        // 输入时间片大小
        System.out.println("请输入时间片大小：");
        int timeQuantum = scanner.nextInt();

        // 执行时间片轮转算法
        int currentTime = 0;
        while (!processQueue.isEmpty()) {
            Process currentProcess = processQueue.poll();
            if (currentProcess.remainingTime > timeQuantum) {
                System.out.println("正在运行进程：" + currentProcess.name + "，执行时间片");
                currentTime += timeQuantum;
                currentProcess.remainingTime -= timeQuantum;

                processQueue.add(currentProcess);
            } else {
                System.out.println("正在运行进程：" + currentProcess.name + "，执行完毕");
                currentTime += currentProcess.remainingTime;
                currentProcess.remainingTime = 0;
            }
        }

        System.out.println("所有进程执行完毕，总运行时间：" + currentTime);
    }
}