Java FCFS调度算法的实现

Java实现FCFS调度算法的步骤如下：

1. 定义进程类Process，包括进程ID、进程到达时间、进程服务时间等属性。
2. 定义一个存储所有进程的队列，按照到达时间从小到大排序。
3. 定义一个当前时间变量，初始值为0。
4. 循环遍历队列中的所有进程，根据当前时间和进程到达时间的差值确定进程的等待时间，更新当前时间，计算进程的完成时间和周转时间。
5. 计算所有进程的平均周转时间和平均带权周转时间。

以下是Java代码实现：

import java.util.*;

class Process {
    private int id; // 进程ID
    private int arrivalTime; // 到达时间
    private int serviceTime; // 服务时间
    private int waitingTime; // 等待时间
    private int finishTime; // 完成时间

    public Process(int id, int arrivalTime, int serviceTime) {
        this.id = id;
        this.arrivalTime = arrivalTime;
        this.serviceTime = serviceTime;
    }

    public int getId() {
        return id;
    }

    public int getArrivalTime() {
        return arrivalTime;
    }

    public int getServiceTime() {
        return serviceTime;
    }

    public int getWaitingTime() {
        return waitingTime;
    }

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

    public int getFinishTime() {
        return finishTime;
    }

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

public class FCFS {
    public static void main(String[] args) {
        List<Process> queue = new ArrayList<>(); // 进程队列
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入进程数：");
        int n = scanner.nextInt();

        // 输入每个进程的到达时间和服务时间
        for (int i = 1; i <= n; i++) {
            System.out.print("请输入第" + i + "个进程的到达时间和服务时间：");
            int arrivalTime = scanner.nextInt();
            int serviceTime = scanner.nextInt();
            queue.add(new Process(i, arrivalTime, serviceTime));
        }

        // 按照到达时间从小到大排序
        queue.sort(Comparator.comparing(Process::getArrivalTime));

        int currentTime = 0; // 当前时间
        double avgTurnaroundTime = 0; // 平均周转时间
        double avgWeightedTurnaroundTime = 0; // 平均带权周转时间

        // 循环遍历队列中的所有进程
        for (Process process : queue) {
            int waitingTime = currentTime - process.getArrivalTime(); // 计算等待时间
            process.setWaitingTime(waitingTime); // 更新等待时间
            int finishTime = currentTime + process.getServiceTime(); // 计算完成时间
            process.setFinishTime(finishTime); // 更新完成时间
            currentTime = finishTime; // 更新当前时间

            int turnaroundTime = finishTime - process.getArrivalTime(); // 计算周转时间
            avgTurnaroundTime += turnaroundTime; // 累加周转时间
            avgWeightedTurnaroundTime += (double)turnaroundTime / process.getServiceTime(); // 累加带权周转时间
        }

        avgTurnaroundTime /= n; // 计算平均周转时间
        avgWeightedTurnaroundTime /= n; // 计算平均带权周转时间

        // 输出每个进程的等待时间、完成时间、周转时间和带权周转时间
        System.out.println("进程ID\t到达时间\t服务时间\t等待时间\t完成时间\t周转时间\t带权周转时间");
        for (Process process : queue) {
            System.out.printf("%d\t%d\t%d\t%d\t%d\t%d\t%.2f\n", process.getId(), process.getArrivalTime(),
                    process.getServiceTime(), process.getWaitingTime(), process.getFinishTime(),
                    process.getFinishTime() - process.getArrivalTime(), (double)(process.getFinishTime() - process.getArrivalTime()) / process.getServiceTime());
        }

        // 输出平均周转时间和平均带权周转时间
        System.out.printf("平均周转时间：%.2f\n", avgTurnaroundTime);
        System.out.printf("平均带权周转时间：%.2f\n", avgWeightedTurnaroundTime);
    }
}