Java实现先来先服务算法，PCB里需要有进程名，进程状态，运行时间和到达时间

好的，以下是Java实现先来先服务算法的示例代码：

import java.util.*;

// 定义进程类
class Process {
    String name;  // 进程名
    int state;  // 进程状态，0表示未执行，1表示执行中，2表示已完成
    int runTime;  // 运行时间
    int arriveTime;  // 到达时间

    public Process(String name, int runTime, int arriveTime) {
        this.name = name;
        this.state = 0;
        this.runTime = runTime;
        this.arriveTime = arriveTime;
    }
}

public class FCFS {
    public static void main(String[] args) {
        List<Process> processes = new ArrayList<>();
        processes.add(new Process("P1", 10, 0));
        processes.add(new Process("P2", 5, 1));
        processes.add(new Process("P3", 8, 2));
        processes.add(new Process("P4", 3, 3));

        int time = 0;  // 当前时间
        int finished = 0;  // 已完成的进程数
        double sumTurnaroundTime = 0;  // 总周转时间
        double sumWaitTime = 0;  // 总等待时间

        // 按到达时间排序
        Collections.sort(processes, new Comparator<Process>() {
            @Override
            public int compare(Process p1, Process p2) {
                return p1.arriveTime - p2.arriveTime;
            }
        });

        // 执行进程
        while (finished < processes.size()) {
            // 找到未执行的进程中到达时间最早的进程
            Process p = null;
            for (int i = 0; i < processes.size(); i++) {
                if (processes.get(i).state == 0) {
                    if (p == null || processes.get(i).arriveTime < p.arriveTime) {
                        p = processes.get(i);
                    }
                }
            }

            // 如果当前时间小于进程的到达时间，等待进程到达
            if (time < p.arriveTime) {
                time = p.arriveTime;
            }

            // 执行进程
            p.state = 1;
            time += p.runTime;
            p.state = 2;
            finished++;

            // 计算周转时间和等待时间
            double turnaroundTime = time - p.arriveTime;
            sumTurnaroundTime += turnaroundTime;
            double waitTime = turnaroundTime - p.runTime;
            sumWaitTime += waitTime;
        }

        // 计算平均周转时间和平均等待时间
        double avgTurnaroundTime = sumTurnaroundTime / processes.size();
        double avgWaitTime = sumWaitTime / processes.size();

        // 输出结果
        System.out.println("进程名\t状态\t运行时间\t到达时间");
        for (int i = 0; i < processes.size(); i++) {
            Process p = processes.get(i);
            System.out.println(p.name + "\t" + p.state + "\t" + p.runTime + "\t\t" + p.arriveTime);
        }
        System.out.println("平均周转时间：" + avgTurnaroundTime);
        System.out.println("平均等待时间：" + avgWaitTime);
    }
}

在上面的代码中，我们定义了一个 `Process` 类表示进程，其中包含了进程名、进程状态、运行时间和到达时间四个属性。然后我们通过一个 `List` 对象来保存所有进程。在主函数中，我们首先按到达时间对进程进行排序，然后使用一个 `while` 循环来模拟执行进程的过程，直到所有进程都执行完毕。在循环中，我们每次找到未执行的进程中到达时间最早的进程，然后执行该进程，计算周转时间和等待时间，并更新已完成的进程数。最后，我们输出所有进程的状态以及平均周转时间和平均等待时间。

需要注意的是，上面的代码中只是一个简单的示例，实际应用中可能需要考虑更多的情况，比如进程的优先级、中断等。