1、编写程序，模拟短作业优先任务。JAVA

好的，以下是一个简单的 Java 代码实现短作业优先调度算法的模拟:

import java.util.*;

class Process implements Comparable<Process> {
    private int pid; // 进程 ID
    private int arrivalTime; // 到达时间
    private int burstTime; // 执行时间
    private int waitingTime; // 等待时间
    private int turnaroundTime; // 周转时间
    private int remainingTime; // 剩余时间

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

    public int getPid() {
        return pid;
    }

    public int getArrivalTime() {
        return arrivalTime;
    }

    public int getBurstTime() {
        return burstTime;
    }

    public int getWaitingTime() {
        return waitingTime;
    }

    public int getTurnaroundTime() {
        return turnaroundTime;
    }

    public int getRemainingTime() {
        return remainingTime;
    }

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

    public void setTurnaroundTime(int turnaroundTime) {
        this.turnaroundTime = turnaroundTime;
    }

    public void setRemainingTime(int remainingTime) {
        this.remainingTime = remainingTime;
    }

    @Override
    public int compareTo(Process other) {
        return this.burstTime - other.burstTime;
    }
}

public class SJF {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        // 输入进程数和每个进程的到达时间和执行时间
        System.out.print("请输入进程数：");
        int n = input.nextInt();
        Process[] processes = new Process[n];
        for (int i = 0; i < n; i++) {
            System.out.print("请输入进程 " + (i+1) + " 的到达时间和执行时间：");
            int arrivalTime = input.nextInt();
            int burstTime = input.nextInt();
            processes[i] = new Process(i+1, arrivalTime, burstTime);
        }

        // 对进程按到达时间进行排序
        Arrays.sort(processes, Comparator.comparingInt(Process::getArrivalTime));

        // 模拟调度过程
        int currentTime = 0;
        double waitingTimeSum = 0, turnaroundTimeSum = 0;
        PriorityQueue<Process> pq = new PriorityQueue<>();
        for (int i = 0; i < n || !pq.isEmpty(); ) {
            // 将到达时间小于等于当前时间的进程加入优先队列
            while (i < n && processes[i].getArrivalTime() <= currentTime) {
                pq.offer(processes[i]);
                i++;
            }
            // 如果队列为空，则当前时间后移
            if (pq.isEmpty()) {
                currentTime++;
                continue;
            }
            // 取出优先级最高的进程
            Process currentProcess = pq.poll();
            // 计算等待时间和周转时间
            currentProcess.setWaitingTime(currentTime - currentProcess.getArrivalTime());
            currentProcess.setTurnaroundTime(currentProcess.getWaitingTime() + currentProcess.getBurstTime());
            // 更新统计数据
            waitingTimeSum += currentProcess.getWaitingTime();
            turnaroundTimeSum += currentProcess.getTurnaroundTime();
            // 执行当前进程
            currentTime += currentProcess.getBurstTime();
            // 更新队列中进程的剩余时间
            while (i < n && processes[i].getArrivalTime() <= currentTime) {
                pq.offer(processes[i]);
                i++;
            }
            for (Process p : pq) {
                p.setRemainingTime(currentTime - p.getArrivalTime());
            }
            // 如果当前进程执行完后还有剩余时间，则重新加入队列
            if (currentProcess.getRemainingTime() > 0) {
                pq.offer(currentProcess);
            }
        }

        // 输出平均等待时间和平均周转时间
        double avgWaitingTime = waitingTimeSum / n;
        double avgTurnaroundTime = turnaroundTimeSum / n;
        System.out.println("平均等待时间：" + avgWaitingTime);
        System.out.println("平均周转时间：" + avgTurnaroundTime);
    }
}

在上面的代码中，我们定义了一个 `Process` 类来表示进程，其中包含了进程的 ID、到达时间、执行时间、等待时间、周转时间和剩余时间等信息。我们使用一个优先队列来模拟短作业优先调度算法，每次取出队列中执行时间最短的进程执行，如果当前进程执行完后还有剩余时间，则重新加入队列。最后输出平均等待时间和平均周转时间。

注意，上面的代码中并没有对进程的到达时间进行限制，实际上在短作业优先调度算法中，进程的到达时间也是一个很重要的因素，如果两个进程的执行时间相同，那么优先选择到达时间更早的进程。因此，在实际应用中还需要对到达时间进行处理，例如先按到达时间排序，然后再按执行时间排序。