河北科技大学操作系统课设，进程的调度算法。

河北科技大学操作系统课设，进程的调度算法。

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

public class JobScheduling {

    public static void main(String[] args) {
        Job jobA = new Job("A", 0, 6,3);
        Job jobB = new Job("B", 7, 60,5);
        Job jobC = new Job("C", 8, 20,3);
        Job jobD = new Job("D", 9, 10,1);
        Job jobE = new Job("E", 12, 40,9);
        Job jobF = new Job("F", 15, 8,2);
        Job job[] = {jobA, jobB, jobC, jobD, jobE, jobF};
        // 先用冒泡排序，将它们按到达时间排序
        Bubble_arrived(job);
        // 先来先服务
        FCFS(job);
        // 短作业优先
        SJF(job);
        // 优先级（非抢占式）算法
        PICB1(job);

    }

    // 冒泡排序(到达时间)
    static void Bubble_arrived(Job[] job) {
        Job temp = new Job("", 0, 0,0); // 临时变量
        boolean flag = false; // 标识变量，表示是否进行过交换
        for (int i = 0; i < job.length - 1; i++) {
            for (int j = 0; j < job.length - 1 - i; j++) {
                // 如果前面的数比后面的数大，则交换
                if (job[j].arriveTime > job[j + 1].arriveTime) {
                    if (!flag) flag = true;
                    temp = job[j];
                    job[j] = job[j + 1];
                    job[j + 1] = temp;
                }
            }
            if (!flag) { // 在一趟排序中，一次交换都没有发生过
                break;
            } else {
                flag = false; // 重置flag, 进行下次判断
            }
        }
    }

    // 冒泡排序(需要时间)
    static void Bubble_need(Job[] job) {
        Job temp = new Job("", 0, 0,0); // 临时变量
        boolean flag = false; // 标识变量，表示是否进行过交换
        for (int i = 0; i < job.length - 1; i++) {
            for (int j = 0; j < job.length - 1 - i; j++) {
                // 如果前面的数比后面的数大，则交换
                if (job[j].needTime > job[j + 1].needTime) {
                    if (!flag) flag = true;
                    temp = job[j];
                    job[j] = job[j + 1];
                    job[j + 1] = temp;
                }
            }
            if (!flag) { // 在一趟排序中，一次交换都没有发生过
                break;
            } else {
                flag = false; // 重置flag, 进行下次判断
            }
        }
    }
    // 先来先服务算法
    static void FCFS(Job[] job) {
        double T = 0; // 平均周转时间
        double W = 0; // 平均带权周转时间
        int finish = 0; // 记录完成时间的变化
        double t = 0; // 周转时间
        double w = 0; // 带权周转时间

        System.out.println("先来先服务算法：");
        System.out.print("作业调度顺序：");
        for (Job value : job) {
            // 记录完成时间的变化
            finish = finish + value.needTime;
            // 计算周转时间
            t = finish - value.arriveTime;
            // 计算带权周转时间
            w = t / value.needTime;
            // 记录周转时间总和
            T += t;
            // 记录带权周转时间总和
            W += w;
            System.out.print(value.jobName);
        }
        System.out.println();
        System.out.println("平均周转时间为：" + T / 6);
        System.out.println("平均带权周转时间为：" + W / 6);
        System.out.println("=========================");
    }

    // 短作业优先算法
    static void SJF(Job[] job) {
        int finish = job[0].needTime; // 记录完成时间的变化
        double t = finish - job[0].arriveTime; // 记录周转时间的变化
        double w = t / job[0].needTime; // 记录带权周转时间的变化
        double T = t; // 平均周转时间
        double W = w; // 平均带权周转时间

        int d = 0;// 记录当前选择到的作业号码
        int time = 100;// 记录服务时间的变化
        int[] arr = {1, 0, 0, 0, 0, 0}; // 记录作业的选择情况：1为选中，0为未选中
        boolean flag = false;
        System.out.println("短作业优先算法：");
        System.out.print("作业调度顺序：" + job[0].jobName);
        for (int e = 1; e < job.length; e++) {
            for (int c = 1; c < job.length; c++) {
                /**
                 * 需要判断：该作业在上一个作业完成时，是否已经到达 该作业是否已经执行完毕 该作业的服务时间是否为最小
                 **/
                if (job[c].arriveTime < finish && arr[c] == 0
                        && job[c].needTime < time) {
                    // 如果满足条件
                    d = c; // 暂时记录当前作业的下标
                    time = job[c].needTime; // 暂时记录该作业的服务时间为最小
                    flag = true;
                }
            }
            //如果结束时间到达以后没有进程到达处理器.
            if (!flag) {
                int num = 1; //计数
                //找到最先到达的，且服务时间最短的进程
                for (int i = 1; i < job.length-1; i++) {
                    //1.寻找没被调用且先到达的进程下标
                    if(arr[i] != 1) {
                        num = i;
                        break;
                    }
                }
                Map<Integer, Job> jobMap = new HashMap<>(); //创建一个集合对象
                //2.判断有没有同时先到达的,如果有的话，将所有最先到达的进程重新写入一个集合
                jobMap.put(num, job[num]);//先将第一个num下标的写入集合
                for (int i = 1; i < job.length - 1; i++) {
                    if (arr[i] == 0 && job[num].arriveTime == job[i].arriveTime) {
                        jobMap.put(i, job[i]);
                    }
                }
                //3.2遍历集合寻找服务时间最短的进程
                int min = 1000;//最短时间
                int i = 0;
                int number = num;//最短时间的下标
                for (Map.Entry<Integer, Job> entry : jobMap.entrySet()) {
                    if (job[entry.getKey()].needTime < min) {
                        min = job[entry.getKey()].needTime;
                        number = entry.getKey();
                    }
                }
                d = number;
            }

            arr[d] = 1; // 作业已被调度，设置为1
            time = 100;// 重置
            flag = false; //重置标志
            // 记录完成时间的变化
            finish = finish + job[d].needTime;
            // 计算周转时间
            t = finish - job[d].arriveTime;
            // 计算带权周转时间
            w = t / job[d].needTime;
            // 记录周转时间总和
            T += t;
            // 记录带权周转时间总和
            W += w;
            System.out.print(job[d].jobName);
        }
        System.out.println();
        System.out.println("平均周转时间为：" + T / 6);
        System.out.println("平均带权周转时间为：" + W / 6);
        System.out.println("=========================");
    }
    //优先级调度算法（非抢占式）
    static void PICB1(Job[] job) {
        int finish = job[0].needTime; // 记录完成时间的变化
        double t = finish - job[0].arriveTime; // 记录周转时间的变化
        double w = t / job[0].needTime; // 记录带权周转时间的变化
        double T = t; // 平均周转时间
        double W = w; // 平均带权周转时间
        boolean flag = false;

        int d = 0;// 记录当前选择到的作业号码
        int priotity_number = 0;// 记录优先数
        int[] arr = {1, 0, 0, 0, 0, 0}; // 记录作业的选择情况：1为选中，0为未选中

        System.out.println("优先数调度算法：");
        System.out.print("进程调度顺序：" + job[0].jobName);
        for (int e = 1; e < job.length; e++) {
            for (int c = 1; c < job.length; c++) {
                /**
                 * 需要判断：该进程在上一个进程完成时，是否已经到达 该进程是否已经执行完毕 该进程的优先数是否最小
                 **/
                if (job[c].arriveTime < finish && arr[c] == 0
                        && job[c].priority > priotity_number) {
                    // 如果满足条件
                    d = c; // 暂时记录当前进程的下标
                    priotity_number = job[c].priority; // 暂时记录该进程的优先数最大
                    flag = true;
                }
            }
            //如果结束时间到达以后没有进程到达处理器.
            if (!flag) {
                int num = 1; //计数
                //找到最先到达的，且优先数最高
                for (int i = 1; i < job.length-1; i++) {
                    //1.寻找没被调用且先到达的进程下标
                    if(arr[i] != 1) {
                        num = i;
                        break;
                    }
                }
                Map<Integer, Job> jobMap = new HashMap<>(); //创建一个集合对象
                //2.判断有没有同时先到达的,如果有的话，将所有最先到达的进程重新写入一个集合
                jobMap.put(num, job[num]);//先将第一个num下标的写入集合
                for (int i = 1; i < job.length - 1; i++) {
                    if (arr[i] == 0 && job[num].arriveTime == job[i].arriveTime) {
                        jobMap.put(i, job[i]);
                    }
                }
                //3遍历集合寻找服务时间最短的进程
                int max = 0;//最大优先数
                int i = 0;
                int number = num;//最大优先数的下标
                for (Map.Entry<Integer, Job> entry : jobMap.entrySet()) {
                    if (job[entry.getKey()].priority < max) {
                        max = job[entry.getKey()].priority;
                        number = entry.getKey();
                    }
                }
                d = number;
            }
            arr[d] = 1; // 作业已被调度，设置为1
            priotity_number = 0;// 重置
            // 记录完成时间的变化
            finish = finish + job[d].needTime;
            // 计算周转时间
            t = finish - job[d].arriveTime;
            // 计算带权周转时间
            w = t / job[d].needTime;
            // 记录周转时间总和
            T += t;
            // 记录带权周转时间总和
            W += w;
            System.out.print(job[d].jobName);
        }
        System.out.println();
        System.out.println("平均周转时间为：" + T / 6);
        System.out.println("平均带权周转时间为：" + W / 6);
        System.out.println("=========================");
    }

    static class Job {
        public String jobName; // 作业名
        public int arriveTime; // 到达时间
        public int needTime; // 服务时间
        public int priority;// 优先数

        // 构造器

        public Job(String jobName, int arriveTime, int needTime, int priority) {
            this.jobName = jobName;
            this.arriveTime = arriveTime;
            this.needTime = needTime;
            this.priority = priority;
        }

        @Override
        public String toString() {
            return "Job [jobName=" + jobName + ", arriveTime=" + arriveTime
                    + ", needTime=" + needTime + "]";
        }

    }
}