优先级多道程序系统的作业调度 java对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间

以下是几种常见的作业调度算法的Java实现，包括打印每个作业的运行时刻、完成时刻、周转时间、带权周转时间和平均值：

1. 先来先服务（FCFS）算法

import java.util.*;

public class FCFS {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入作业数：");
        int n = sc.nextInt();
        int[] arriveTime = new int[n];  // 到达时间
        int[] runTime = new int[n];     // 运行时间
        int[] finishTime = new int[n];  // 完成时间
        int[] turnOverTime = new int[n];  // 周转时间
        double[] weightedTurnOverTime = new double[n];  // 带权周转时间
        int sumTurnOverTime = 0;  // 总周转时间
        double sumWeightedTurnOverTime = 0;  // 总带权周转时间
        
        // 输入作业信息
        for (int i = 0; i < n; i++) {
            System.out.print("请输入第" + (i+1) + "个作业的到达时间和运行时间：");
            arriveTime[i] = sc.nextInt();
            runTime[i] = sc.nextInt();
        }
        
        // 计算完成时间、周转时间和带权周转时间
        int curTime = 0;  // 当前时间
        for (int i = 0; i < n; i++) {
            if (curTime < arriveTime[i]) {
                curTime = arriveTime[i];
            }
            finishTime[i] = curTime + runTime[i];
            turnOverTime[i] = finishTime[i] - arriveTime[i];
            weightedTurnOverTime[i] = (double) turnOverTime[i] / runTime[i];
            curTime = finishTime[i];
            sumTurnOverTime += turnOverTime[i];
            sumWeightedTurnOverTime += weightedTurnOverTime[i];
        }
        
        // 输出结果
        System.out.println("作业\t到达时间\t运行时间\t完成时间\t周转时间\t带权周转时间");
        for (int i = 0; i < n; i++) {
            System.out.println((i+1) + "\t" + arriveTime[i] + "\t" + runTime[i] + "\t" + finishTime[i] 
                    + "\t" + turnOverTime[i] + "\t" + String.format("%.2f", weightedTurnOverTime[i]));
        }
        System.out.println("平均周转时间：" + (double) sumTurnOverTime / n);
        System.out.println("平均带权周转时间：" + String.format("%.2f", sumWeightedTurnOverTime / n));
    }
}

2. 短作业优先（SJF）算法

import java.util.*;

public class SJF {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入作业数：");
        int n = sc.nextInt();
        int[] arriveTime = new int[n];  // 到达时间
        int[] runTime = new int[n];     // 运行时间
        int[] finishTime = new int[n];  // 完成时间
        int[] turnOverTime = new int[n];  // 周转时间
        double[] weightedTurnOverTime = new double[n];  // 带权周转时间
        int sumTurnOverTime = 0;  // 总周转时间
        double sumWeightedTurnOverTime = 0;  // 总带权周转时间
        
        // 输入作业信息
        for (int i = 0; i < n; i++) {
            System.out.print("请输入第" + (i+1) + "个作业的到达时间和运行时间：");
            arriveTime[i] = sc.nextInt();
            runTime[i] = sc.nextInt();
        }
        
        // 按到达时间排序
        for (int i = 0; i < n-1; i++) {
            for (int j = 0; j < n-1-i; j++) {
                if (arriveTime[j] > arriveTime[j+1]) {
                    int temp1 = arriveTime[j];
                    arriveTime[j] = arriveTime[j+1];
                    arriveTime[j+1] = temp1;
                    int temp2 = runTime[j];
                    runTime[j] = runTime[j+1];
                    runTime[j+1] = temp2;
                }
            }
        }
        
        // 计算完成时间、周转时间和带权周转时间
        int curTime = 0;  // 当前时间
        int[] flag = new int[n];  // 标记作业是否完成
        Arrays.fill(flag, 0);
        while (true) {
            int minRunTime = Integer.MAX_VALUE;  // 最短运行时间
            int idx = -1;  // 最短作业的下标
            for (int i = 0; i < n; i++) {
                if (flag[i] == 0 && runTime[i] < minRunTime && arriveTime[i] <= curTime) {
                    minRunTime = runTime[i];
                    idx = i;
                }
            }
            if (idx == -1) {
                break;
            }
            finishTime[idx] = curTime + runTime[idx];
            turnOverTime[idx] = finishTime[idx] - arriveTime[idx];
            weightedTurnOverTime[idx] = (double) turnOverTime[idx] / runTime[idx];
            curTime = finishTime[idx];
            flag[idx] = 1;
            sumTurnOverTime += turnOverTime[idx];
            sumWeightedTurnOverTime += weightedTurnOverTime[idx];
        }
        
        // 输出结果
        System.out.println("作业\t到达时间\t运行时间\t完成时间\t周转时间\t带权周转时间");
        for (int i = 0; i < n; i++) {
            System.out.println((i+1) + "\t" + arriveTime[i] + "\t" + runTime[i] + "\t" + finishTime[i] 
                    + "\t" + turnOverTime[i] + "\t" + String.format("%.2f", weightedTurnOverTime[i]));
        }
        System.out.println("平均周转时间：" + (double) sumTurnOverTime / n);
        System.out.println("平均带权周转时间：" + String.format("%.2f", sumWeightedTurnOverTime / n));
    }
}

3. 优先级调度算法

import java.util.*;

public class Priority {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入作业数：");
        int n = sc.nextInt();
        int[] arriveTime = new int[n];  // 到达时间
        int[] runTime = new int[n];     // 运行时间
        int[] priority = new int[n];    // 优先级
        int[] finishTime = new int[n];  // 完成时间
        int[] turnOverTime = new int[n];  // 周转时间
        double[] weightedTurnOverTime = new double[n];  // 带权周转时间
        int sumTurnOverTime = 0;  // 总周转时间
        double sumWeightedTurnOverTime = 0;  // 总带权周转时间
        
        // 输入作业信息
        for (int i = 0; i < n; i++) {
            System.out.print("请输入第" + (i+1) + "个作业的到达时间、运行时间和优先级：");
            arriveTime[i] = sc.nextInt();
            runTime[i] = sc.nextInt();
            priority[i] = sc.nextInt();
        }
        
        // 按到达时间排序
        for (int i = 0; i < n-1; i++) {
            for (int j = 0; j < n-1-i; j++) {
                if (arriveTime[j] > arriveTime[j+1]) {
                    int temp1 = arriveTime[j];
                    arriveTime[j] = arriveTime[j+1];
                    arriveTime[j+1] = temp1;
                    int temp2 = runTime[j];
                    runTime[j] = runTime[j+1];
                    runTime[j+1] = temp2;
                    int temp3 = priority[j];
                    priority[j] = priority[j+1];
                    priority[j+1] = temp3;
                }
            }
        }
        
        // 计算完成时间、周转时间和带权周转时间
        int curTime = 0;  // 当前时间
        int[] flag = new int[n];  // 标记作业是否完成
        Arrays.fill(flag, 0);
        while (true) {
            int maxPriority = -1;  // 最高优先级
            int idx = -1;  // 优先级最高的作业的下标
            for (int i = 0; i < n; i++) {
                if (flag[i] == 0 && priority[i] > maxPriority && arriveTime[i] <= curTime) {
                    maxPriority = priority[i];
                    idx = i;
                }
            }
            if (idx == -1) {
                break;
            }
            finishTime[idx] = curTime + runTime[idx];
            turnOverTime[idx] = finishTime[idx] - arriveTime[idx];
            weightedTurnOverTime[idx] = (double) turnOverTime[idx] / runTime[idx];
            curTime = finishTime[idx];
            flag[idx] = 1;
            sumTurnOverTime += turnOverTime[idx];
            sumWeightedTurnOverTime += weightedTurnOverTime[idx];
        }
        
        // 输出结果
        System.out.println("作业\t到达时间\t运行时间\t优先级\t完成时间\t周转时间\t带权周转时间");
        for (int i = 0; i < n; i++) {
            System.out.println((i+1) + "\t" + arriveTime[i] + "\t" + runTime[i] + "\t" + priority[i] 
                    + "\t" + finishTime[i] + "\t" + turnOverTime[i] + "\t" + String.format("%.2f", weightedTurnOverTime[i]));
        }
        System.out.println("平均周转时间：" + (double) sumTurnOverTime / n);
        System.out.println("平均带权周转时间：" + String.format("%.2f", sumWeightedTurnOverTime / n));
    }
}

以上是三种作业调度算法的Java实现，均包括打印每个作业的运行时刻、完成时刻、周转时间、带权周转时间和平均值。