javaSJF算法的实现

SJF（Shortest Job First）算法是一种作业调度算法，它优先调度执行时间最短的作业。以下是Java实现SJF算法的代码示例：

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

class Process {
    private int pid; // 进程id
    private int arrivalTime; // 到达时间
    private int burstTime; // 执行时间
    private int completionTime; // 完成时间
    private int turnAroundTime; // 周转时间
    private int waitingTime; // 等待时间

    public Process(int pid, int arrivalTime, int burstTime) {
        this.pid = pid;
        this.arrivalTime = arrivalTime;
        this.burstTime = burstTime;
    }

    public int getPid() {
        return pid;
    }

    public int getArrivalTime() {
        return arrivalTime;
    }

    public int getBurstTime() {
        return burstTime;
    }

    public int getCompletionTime() {
        return completionTime;
    }

    public void setCompletionTime(int completionTime) {
        this.completionTime = completionTime;
    }

    public int getTurnAroundTime() {
        return turnAroundTime;
    }

    public void setTurnAroundTime(int turnAroundTime) {
        this.turnAroundTime = turnAroundTime;
    }

    public int getWaitingTime() {
        return waitingTime;
    }

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

public class SJF {
    public static void main(String[] args) {
        List<Process> processes = new ArrayList<>();
        processes.add(new Process(1, 0, 6));
        processes.add(new Process(2, 1, 8));
        processes.add(new Process(3, 2, 7));
        processes.add(new Process(4, 3, 3));

        PriorityQueue<Process> readyQueue = new PriorityQueue<>(Comparator.comparingInt(Process::getBurstTime));

        int currentTime = 0;
        int totalWaitingTime = 0;
        int totalTurnAroundTime = 0;

        while (!processes.isEmpty() || !readyQueue.isEmpty()) {
            while (!processes.isEmpty() && processes.get(0).getArrivalTime() <= currentTime) {
                Process process = processes.remove(0);
                readyQueue.add(process);
            }

            if (readyQueue.isEmpty()) {
                currentTime++;
                continue;
            }

            Process process = readyQueue.poll();
            process.setCompletionTime(currentTime + process.getBurstTime());
            process.setTurnAroundTime(process.getCompletionTime() - process.getArrivalTime());
            process.setWaitingTime(process.getTurnAroundTime() - process.getBurstTime());

            totalWaitingTime += process.getWaitingTime();
            totalTurnAroundTime += process.getTurnAroundTime();
            currentTime = process.getCompletionTime();
        }

        int n = processes.size();
        double avgWaitingTime = (double) totalWaitingTime / n;
        double avgTurnAroundTime = (double) totalTurnAroundTime / n;

        System.out.println("平均等待时间：" + avgWaitingTime);
        System.out.println("平均周转时间：" + avgTurnAroundTime);
    }
}

上述代码中，我们定义了一个Process类来表示进程，其中包含进程的id、到达时间、执行时间等信息。我们使用一个列表（List）来存储所有的进程，使用一个优先队列（PriorityQueue）来存储就绪队列中的进程，优先队列根据进程的执行时间升序排列。

在主函数中，我们初始化了四个进程，并将它们加入到进程列表中。然后我们定义了三个变量，分别表示当前时间、总等待时间和总周转时间。在主循环中，我们首先将所有到达时间小于等于当前时间的进程加入到就绪队列中，然后从就绪队列中取出执行时间最短的进程执行。执行完毕后，我们计算该进程的完成时间、周转时间和等待时间，并更新总等待时间、总周转时间和当前时间。

最后，我们计算平均等待时间和平均周转时间，并输出结果。