【轮转算法】

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

class Process {
    private int id;
    private int arrivalTime;
    private int burstTime;
    private int priority;
    private int waitingTime;
    private int turnaroundTime;

    public Process(int id, int arrivalTime, int burstTime, int priority) {
        this.id = id;
        this.arrivalTime = arrivalTime;
        this.burstTime = burstTime;
        this.priority = priority;
        this.waitingTime = 0;
        this.turnaroundTime = 0;
    }

    public int getId() {
        return id;
    }

    public int getArrivalTime() {
        return arrivalTime;
    }

    public int getBurstTime() {
        return burstTime;
    }

    public int getPriority() {
        return priority;
    }

    public int getWaitingTime() {
        return waitingTime;
    }

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

    public int getTurnaroundTime() {
        return turnaroundTime;
    }

    public void setTurnaroundTime(int turnaroundTime) {
        this.turnaroundTime = turnaroundTime;
    }
}

public class ProcessScheduler {
    private Queue<Process> readyQueue;
    private List<Process> completedProcesses;

    public ProcessScheduler() {
        this.readyQueue = new LinkedList<>();
        this.completedProcesses = new ArrayList<>();
    }

    public void addProcess(Process process) {
        readyQueue.add(process);
    }

    public void runSimpleRoundRobin(int quantum) {
        Queue<Process> roundRobinQueue = new LinkedList<>(readyQueue);
        while (!roundRobinQueue.isEmpty()) {
            Process currentProcess = roundRobinQueue.poll();
            int remainingBurstTime = currentProcess.getBurstTime();
            while (remainingBurstTime > 0) {
                if (remainingBurstTime > quantum) {
                    remainingBurstTime -= quantum;
                    currentProcess.setBurstTime(remainingBurstTime);
                    roundRobinQueue.add(currentProcess);
                } else {
                    remainingBurstTime = 0;
                    currentProcess.setTurnaroundTime(currentProcess.getWaitingTime() + currentProcess.getBurstTime());
                    completedProcesses.add(currentProcess);
                }
            }
        }
    }

    public void runPriorityScheduling() {
        List<Process> sortedProcesses = new ArrayList<>(readyQueue);
        sortedProcesses.sort((p1, p2) -> p1.getPriority() - p2.getPriority());

        int currentTime = 0;
        for (Process process : sortedProcesses) {
            process.setWaitingTime(currentTime - process.getArrivalTime());
            process.setTurnaroundTime(process.getWaitingTime() + process.getBurstTime());
            completedProcesses.add(process);
            currentTime += process.getBurstTime();
        }
    }

    public void printProcessDetails() {
        int totalWaitingTime = 0;
        int totalTurnaroundTime = 0;
        System.out.println("Process\tArrival Time\tBurst Time\tPriority\tWaiting Time\tTurnaround Time");
        for (Process process : completedProcesses) {
            System.out.println(process.getId() + "\t\t" + process.getArrivalTime() + "\t\t\t" + process.getBurstTime()
                    + "\t\t\t" + process.getPriority() + "\t\t\t" + process.getWaitingTime() + "\t\t\t\t"
                    + process.getTurnaroundTime());
            totalWaitingTime += process.getWaitingTime();
            totalTurnaroundTime += process.getTurnaroundTime();
        }
        int avgWaitingTime = totalWaitingTime / completedProcesses.size();
        int avgTurnaroundTime = totalTurnaroundTime / completedProcesses.size();
        System.out.println("\nAverage Waiting Time: " + avgWaitingTime);
        System.out.println("Average Turnaround Time: " + avgTurnaroundTime);
    }

    public static void main(String[] args) {
        ProcessScheduler scheduler = new ProcessScheduler();

        // 添加进程到调度程序
        scheduler.addProcess(new Process(1, 0, 6, 2));
        scheduler.addProcess(new Process(2, 2, 4, 1));
        scheduler.addProcess(new Process(3, 4, 9, 3));
        scheduler.addProcess(new Process(4, 6, 2, 4));
        scheduler.addProcess(new Process(5, 8, 5, 2));

        // 运行简单轮转法，每个时间片的长度为2
        scheduler.runSimpleRoundRobin(2);
        scheduler.printProcessDetails();

        // 清空已完成的进程列表
        scheduler.completedProcesses.clear();

        // 运行优先数法
        scheduler.runPriorityScheduling();
        scheduler.printProcessDetails();
    }
}