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

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

1. 使用数组实现

import java.util.*;

public class FCFS {
    public static void main(String[] args) {
        String[] names = {"P1", "P2", "P3", "P4"};  // 进程名
        int[] states = new int[names.length];  // 进程状态，0表示未执行，1表示执行中，2表示已完成
        int[] runTimes = {10, 5, 8, 3};  // 运行时间
        int[] arriveTimes = {0, 1, 2, 3};  // 到达时间

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

        // 按到达时间排序
        for (int i = 0; i < arriveTimes.length - 1; i++) {
            for (int j = i + 1; j < arriveTimes.length; j++) {
                if (arriveTimes[i] > arriveTimes[j]) {
                    int temp = arriveTimes[i];
                    arriveTimes[i] = arriveTimes[j];
                    arriveTimes[j] = temp;
                    temp = runTimes[i];
                    runTimes[i] = runTimes[j];
                    runTimes[j] = temp;
                    String s = names[i];
                    names[i] = names[j];
                    names[j] = s;
                }
            }
        }

        // 执行进程
        while (finished < names.length) {
            // 找到未执行的进程中到达时间最早的进程
            int index = -1;
            for (int i = 0; i < names.length; i++) {
                if (states[i] == 0) {
                    if (index == -1 || arriveTimes[i] < arriveTimes[index]) {
                        index = i;
                    }
                }
            }

            // 如果当前时间小于进程的到达时间，等待进程到达
            if (time < arriveTimes[index]) {
                time = arriveTimes[index];
            }

            // 执行进程
            states[index] = 1;
            time += runTimes[index];
            states[index] = 2;
            finished++;

            // 计算周转时间和等待时间
            double turnaroundTime = time - arriveTimes[index];
            sumTurnaroundTime += turnaroundTime;
            double waitTime = turnaroundTime - runTimes[index];
            sumWaitTime += waitTime;
        }

        // 计算平均周转时间和平均等待时间
        double avgTurnaroundTime = sumTurnaroundTime / names.length;
        double avgWaitTime = sumWaitTime / names.length;

        // 输出结果
        System.out.println("进程名\t状态\t运行时间\t到达时间");
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i] + "\t" + states[i] + "\t" + runTimes[i] + "\t\t" + arriveTimes[i]);
        }
        System.out.println("平均周转时间：" + avgTurnaroundTime);
        System.out.println("平均等待时间：" + avgWaitTime);
    }
}

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

2. 使用链表实现

import java.util.*;

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

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

public class FCFS {
    public static void main(String[] args) {
        Process head = null, tail = null;  // 链表头和尾
        head = tail = new Process("P1", 10, 0);
        tail.next = new Process("P2", 5, 1);
        tail = tail.next;
        tail.next = new Process("P3", 8, 2);
        tail = tail.next;
        tail.next = new Process("P4", 3, 3);
        tail = tail.next;

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

        // 执行进程
        while (finished < 4) {
            // 找到未执行的进程中到达时间最早的进程
            Process p = null, prev = null, q = head;
            while (q != null) {
                if (q.state == 0 && (p == null || q.arriveTime < p.arriveTime)) {
                    p = q;
                    prev = prev == null ? head : prev.next;
                }
                q = q.next;
            }

            // 如果当前时间小于进程的到达时间，等待进程到达
            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;

            // 从链表中删除已完成的进程
            if (prev == null) {
                head = p.next;
            } else {
                prev.next = p.next;
            }
        }

        // 计算平均周转时间和平均等待时间
        double avgTurnaroundTime = sumTurnaroundTime / 4;
        double avgWaitTime = sumWaitTime / 4;

        // 输出结果
        System.out.println("进程名\t状态\t运行时间\t到达时间");
        Process p = head;
        while (p != null) {
            System.out.println(p.name + "\t" + p.state + "\t" + p.runTime + "\t\t" + p.arriveTime);
            p = p.next;
        }
        System.out.println("平均周转时间：" + avgTurnaroundTime);
        System.out.println("平均等待时间：" + avgWaitTime);
    }
}

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

3. 使用优先队列实现

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;
            }
        });

        // 使用优先队列来保存所有进程
        Queue<Process> queue = new PriorityQueue<>(new Comparator<Process>() {
            @Override
            public int compare(Process p1, Process p2) {
                return p1.arriveTime - p2.arriveTime;
            }
        });
        for (int i = 0; i < processes.size(); i++) {
            queue.offer(processes.get(i));
        }

        // 执行进程
        while (finished < processes.size()) {
            // 找到未执行的进程中到达时间最早的进程
            Process p = queue.poll();

            // 如果当前时间小于进程的到达时间，等待进程到达
            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` 循环来模拟执行进程的过程，直到所有进程都执行完毕。在循环中，我们每次弹出队列中到达时间最早的进程，然后执行该进程，计算周转时间和等待时间，并更新已完成的进程数。最后，我们输出所有进程的状态以及平均周转时间和平均等待时间。

需要注意的是，上面的代码中只是一个简单的示例，实际应用中可能需要考虑更多的情况，比