Java实现短作业优先算法，PCB里需要有进程名，进程状态，运行时间和到达时间

好的，下面是Java实现短作业优先算法的示例代码，包括PCB类的定义和短作业优先算法的实现：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class PCB {
    private String processName; // 进程名
    private int status; // 进程状态，0表示未到达，1表示已到达未执行，2表示正在执行，3表示已完成
    private int arrivalTime; // 到达时间
    private int runTime; // 运行时间

    public PCB(String processName, int status, int arrivalTime, int runTime) {
        this.processName = processName;
        this.status = status;
        this.arrivalTime = arrivalTime;
        this.runTime = runTime;
    }

    public String getProcessName() {
        return processName;
    }

    public void setProcessName(String processName) {
        this.processName = processName;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public int getArrivalTime() {
        return arrivalTime;
    }

    public void setArrivalTime(int arrivalTime) {
        this.arrivalTime = arrivalTime;
    }

    public int getRunTime() {
        return runTime;
    }

    public void setRunTime(int runTime) {
        this.runTime = runTime;
    }
}

public class ShortestJobFirst {
    public static void main(String[] args) {
        ArrayList<PCB> pcbList = new ArrayList<PCB>();
        // 添加进程到 PCB 列表中
        pcbList.add(new PCB("P1", 0, 0, 5));
        pcbList.add(new PCB("P2", 0, 1, 3));
        pcbList.add(new PCB("P3", 0, 2, 8));
        pcbList.add(new PCB("P4", 0, 3, 6));
        // 按照到达时间排序
        Collections.sort(pcbList, new Comparator<PCB>() {
            @Override
            public int compare(PCB pcb1, PCB pcb2) {
                return pcb1.getArrivalTime() - pcb2.getArrivalTime();
            }
        });

        int currentTime = 0; // 当前时间
        int nextProcessIndex = 0; // 下一个需要执行的进程的索引
        int finishCount = 0; // 完成的进程数
        while (finishCount < pcbList.size()) {
            // 查找下一个需要执行的进程
            PCB nextProcess = null;
            int shortestRunTime = Integer.MAX_VALUE;
            for (int i = nextProcessIndex; i < pcbList.size(); i++) {
                PCB pcb = pcbList.get(i);
                if (pcb.getStatus() == 0) {
                    nextProcess = pcb;
                    nextProcessIndex = i;
                    break;
                } else if (pcb.getStatus() == 1 && pcb.getRunTime() < shortestRunTime) {
                    nextProcess = pcb;
                    nextProcessIndex = i;
                    shortestRunTime = pcb.getRunTime();
                }
            }
            // 如果找到了需要执行的进程
            if (nextProcess != null) {
                nextProcess.setStatus(2); // 设置进程状态为执行中
                int executeTime = Math.min(nextProcess.getRunTime(), nextProcess.getArrivalTime() + nextProcess.getRunTime() - currentTime); // 计算执行时间
                currentTime += executeTime; // 更新当前时间
                nextProcess.setRunTime(nextProcess.getRunTime() - executeTime); // 更新剩余运行时间
                if (nextProcess.getRunTime() == 0) {
                    nextProcess.setStatus(3); // 设置进程状态为已完成
                    finishCount++; // 更新完成的进程数
                }
            } else {
                currentTime++; // 如果没有需要执行的进程，则当前时间加 1
            }
        }

        // 输出每个进程的执行时间
        for (PCB pcb : pcbList) {
            System.out.println(pcb.getProcessName() + " " + (pcb.getArrivalTime() + pcb.getRunTime()) + " " + pcb.getStatus());
        }
    }
}

在这个示例代码中，我们定义了一个 PCB 类来表示进程的信息，包括进程名、进程状态、到达时间和运行时间。然后我们使用 ArrayList 来存储 PCB 列表，并按照到达时间排序。接着我们使用一个 while 循环来模拟进程的执行过程，每次查找下一个需要执行的进程，并计算它需要执行的时间。当一个进程完成执行时，我们就更新它的状态和剩余运行时间，并统计完成的进程数。最后，我们输出每个进程的执行时间。