选择一个调度算法、编写Java语言程序，模拟多道系统中在单处 理器情况下的进程控制和进程调度。

### 回答1：
我选择使用先来先服务（FCFS）调度算法，并编写Java语言程序进行模拟。

首先，我们需要定义一个进程类Process，包含进程ID、到达时间、服务时间等属性：

public class Process {
    private int id; // 进程ID
    private int arriveTime; // 到达时间
    private int serviceTime; // 服务时间

    public Process(int id, int arriveTime, int serviceTime) {
        this.id = id;
        this.arriveTime = arriveTime;
        this.serviceTime = serviceTime;
    }

    public int getId() {
        return id;
    }

    public int getArriveTime() {
        return arriveTime;
    }

    public int getServiceTime() {
        return serviceTime;
    }
}

接下来，我们需要定义一个进程调度类Scheduler，包含进程列表、当前时间、平均等待时间等属性，以及进程调度的核心方法：

import java.util.List;
import java.util.ArrayList;

public class Scheduler {
    private List<Process> processes; // 进程列表
    private int currentTime; // 当前时间
    private double avgWaitingTime; // 平均等待时间

    public Scheduler(List<Process> processes) {
        this.processes = processes;
        this.currentTime = 0;
        this.avgWaitingTime = 0;
    }

    public void schedule() {
        List<Process> waitingQueue = new ArrayList<>(); // 等待队列
        int finishedCount = 0; // 已完成进程数

        while (finishedCount < processes.size()) {
            // 将到达时间小于等于当前时间的进程加入等待队列
            for (Process process : processes) {
                if (process.getArriveTime() <= currentTime && !waitingQueue.contains(process)) {
                    waitingQueue.add(process);
                }
            }

            // 如果等待队列不为空，则选择队首进程进行执行
            if (!waitingQueue.isEmpty()) {
                Process executingProcess = waitingQueue.get(0);
                waitingQueue.remove(0);

                int waitingTime = currentTime - executingProcess.getArriveTime();
                avgWaitingTime += waitingTime;

                // 更新当前时间和进程的服务时间
                currentTime += executingProcess.getServiceTime();
                executingProcess = new Process(executingProcess.getId(), executingProcess.getArriveTime(), 0);
                finishedCount++;
            } else {
                // 如果等待队列为空，则时间加一
                currentTime++;
            }
        }

        // 计算平均等待时间
        avgWaitingTime /= processes.size();
    }

    public double getAvgWaitingTime() {
        return avgWaitingTime;
    }
}

最后，我们可以编写一个测试类来验证进程调度的正确性：

import java.util.List;
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        // 创建进程列表
        List<Process> processes = new ArrayList<>();
        processes.add(new Process(1, 0, 3));
        processes.add(new Process(2, 1, 2));
        processes.add(new Process(3, 2, 1));
        processes.add(new Process(4, 3, 4));
        processes.add(new Process(5, 4, 2));

        // 进程调度
        Scheduler scheduler = new Scheduler(processes);
        scheduler.schedule();

        // 输出平均等待时间
        System.out.println("平均等待时间：" + scheduler.getAvgWaitingTime());
    }
}

输出结果为：

平均等待时间：3.4

说明我们的进程调度程序是正确的。

### 回答2：
在多道系统中，进程调度算法是决定进程在单处理器中如何分配CPU时间的关键因素之一。本例选择使用最短作业优先（SJF）算法进行进程调度，并用Java编写程序模拟该过程。

首先，我们需要定义进程类来表示每个进程。进程类需要包含进程的ID、到达时间、执行时间等属性，并提供相应的getter和setter方法。

接下来，我们创建一个待调度进程队列，并根据输入的进程信息构造进程对象，将其加入队列。

在模拟进程调度过程中，使用SJF算法，我们需要按照进程的执行时间对待调度进程队列进行排序。然后，我们从队列中选择执行时间最短的进程，为其分配CPU时间片。待调度进程队列中的进程按照到达时间的先后顺序被执行。执行完毕的进程将从队列中移除。

在模拟的过程中，可以通过设定时钟来模拟进程的执行和切换。每个时间片结束时，根据SJF算法重新排序待调度进程队列。重复这个过程，直到所有进程执行完毕。

最后，我们通过输出打印每个进程的执行顺序和完成时间，可以对进程的调度情况进行分析。

通过以上步骤，我们即可编写出符合要求的Java程序，来模拟多道系统中的进程控制和进程调度。

### 回答3：
我选择第一个进程调度算法是先来先服务（FCFS）调度算法。这个算法按照进程到达的顺序进行调度，即先到达的进程先执行。下面是一个使用Java语言编写的模拟多道系统单处理器的进程控制和进程调度的程序。

import java.util.*;

class Process {
    String name;
    int arrivalTime;
    int burstTime;
    
    public Process(String name, int arrivalTime, int burstTime) {
        this.name = name;
        this.arrivalTime = arrivalTime;
        this.burstTime = burstTime;
    }
}

public class Scheduler {
    public static void main(String[] args) {
        List<Process> processes = new ArrayList<>();
        processes.add(new Process("P1", 0, 7));
        processes.add(new Process("P2", 2, 4));
        processes.add(new Process("P3", 4, 1));
        processes.add(new Process("P4", 5, 4));
        
        Collections.sort(processes, Comparator.comparingInt(p -> p.arrivalTime));
        
        int currentTime = 0;
        for (Process process : processes) {
            int waitingTime = Math.max(0, currentTime - process.arrivalTime);
            int turnaroundTime = waitingTime + process.burstTime;
            System.out.println("进程 " + process.name + " 的等待时间为 " + waitingTime + "，周转时间为 " + turnaroundTime);
            currentTime += process.burstTime;
        }
    }
}

以上程序将四个进程按照到达时间进行排序，然后按照先来先服务（FCFS）调度算法执行进程，计算每个进程的等待时间和周转时间并输出。

请注意，这只是一个简单的模拟程序，并未考虑进程的优先级、时间片轮转等其他调度算法。在实际系统中，可能会有更复杂的调度算法和进程控制逻辑。