(1)先来先服务调度算法;(2)短作业优先调度算法;(3)剥夺式优先级调度算法。

(1) 先来先服务调度算法（First Come First Serve，FCFS）是一种最简单的调度算法，按照作业提交的先后顺序进行调度。它的优点是实现简单、公平性好，缺点是平均等待时间较长，不适用于短作业和交互式系统。

(2) 短作业优先调度算法（Shortest Job First，SJF）是按照作业所需的处理时间来安排作业的执行顺序，优先考虑需要执行时间短的作业。它的优点是平均等待时间短，适用于大量短作业的系统，缺点是无法预测作业的执行时间，可能导致长作业等待时间过长。

(3) 剥夺式优先级调度算法（Preemptive Priority Scheduling）是在短作业优先调度算法基础上增加了优先级的概念，当优先级高的作业到达时，会抢占正在执行的作业，重新安排执行顺序。它的优点是可以提高紧急任务的优先级，缺点是可能导致低优先级作业长时间等待，不适用于交互式系统。

相关问题

实现进程调度1—静态非剥夺式优先级调度计算平均作业周转时间的代码

以下是一个简单的静态非剥夺式优先级调度算法的代码示例，用于计算平均作业周转时间：

#include <stdio.h>
#include <stdlib.h>

#define MAX_JOBS 10

typedef struct {
    int pid;        // 进程ID
    int priority;   // 进程优先级
    int arrival;    // 进程到达时间
    int burst;      // 进程执行时间
} Job;

int main() {
    Job jobs[MAX_JOBS];
    int num_jobs, i, j;
    float avg_turnaround = 0.0;

    // 输入作业信息
    printf("请输入作业数（最多%d个）：", MAX_JOBS);
    scanf("%d", &num_jobs);
    for (i = 0; i < num_jobs; i++) {
        printf("请输入第%d个作业的信息（pid, 优先级, 到达时间, 执行时间）：", i + 1);
        scanf("%d %d %d %d", &jobs[i].pid, &jobs[i].priority, &jobs[i].arrival, &jobs[i].burst);
    }

    // 静态非剥夺式优先级调度算法
    Job temp;
    for (i = 0; i < num_jobs - 1; i++) {
        for (j = i + 1; j < num_jobs; j++) {
            if (jobs[i].priority < jobs[j].priority) {
                temp = jobs[i];
                jobs[i] = jobs[j];
                jobs[j] = temp;
            }
        }
    }

    // 计算平均作业周转时间
    int current_time = 0;
    for (i = 0; i < num_jobs; i++) {
        int turnaround = current_time + jobs[i].burst - jobs[i].arrival;
        avg_turnaround += turnaround;
        current_time += jobs[i].burst;
    }
    avg_turnaround /= num_jobs;

    // 输出结果
    printf("平均作业周转时间为：%.2f\n", avg_turnaround);

    return 0;
}

该代码首先输入作业信息，然后使用静态非剥夺式优先级调度算法对作业进行排序，接着计算每个作业的周转时间并计算平均值，最后输出结果。请注意，该代码仅为示例，可能需要根据具体情况进行修改和优化。

java实现进程调度1—静态非剥夺式优先级调度计算平均作业周转时间的代码

以下是 Java 实现进程调度1—静态非剥夺式优先级调度计算平均作业周转时间的代码：

import java.util.*;

class Process {
    int pid;  // 进程 ID
    int bt;   // 进程的运行时间
    int at;   // 进程的到达时间
    int priority;  // 进程的优先级

    public Process(int pid, int bt, int at, int priority) {
        this.pid = pid;
        this.bt = bt;
        this.at = at;
        this.priority = priority;
    }
}

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

        System.out.print("Enter the number of processes: ");
        int n = sc.nextInt();

        Process[] processes = new Process[n];
        for (int i = 0; i < n; i++) {
            System.out.println("Enter the details of process " + (i+1) + ":");
            System.out.print("Burst Time: ");
            int bt = sc.nextInt();
            System.out.print("Arrival Time: ");
            int at = sc.nextInt();
            System.out.print("Priority: ");
            int priority = sc.nextInt();
            processes[i] = new Process(i+1, bt, at, priority);
        }

        // Sort the processes based on their arrival time
        Arrays.sort(processes, (p1, p2) -> p1.at - p2.at);

        int[] ct = new int[n];  // Completion Time
        int[] tat = new int[n];  // Turnaround Time
        int[] wt = new int[n];  // Waiting Time

        // Initialize the first process
        ct[0] = processes[0].at + processes[0].bt;
        tat[0] = ct[0] - processes[0].at;
        wt[0] = tat[0] - processes[0].bt;

        // Calculate completion time, turnaround time and waiting time for each process
        for (int i = 1; i < n; i++) {
            int shortestJobIndex = i;
            for (int j = i; j < n; j++) {
                if (processes[j].priority < processes[shortestJobIndex].priority) {
                    shortestJobIndex = j;
                }
            }
            Process shortestJob = processes[shortestJobIndex];
            processes[shortestJobIndex] = processes[i];
            processes[i] = shortestJob;
            ct[i] = ct[i-1] + processes[i].bt;
            tat[i] = ct[i] - processes[i].at;
            wt[i] = tat[i] - processes[i].bt;
        }

        // Calculate average turnaround time and waiting time
        double avgTAT = Arrays.stream(tat).average().getAsDouble();
        double avgWT = Arrays.stream(wt).average().getAsDouble();

        // Print the results
        System.out.println("\nProcess\tBurst Time\tArrival Time\tPriority\tCompletion Time\tTurnaround Time\tWaiting Time");
        for (int i = 0; i < n; i++) {
            System.out.println(processes[i].pid + "\t\t" + processes[i].bt + "\t\t" + processes[i].at + "\t\t" + processes[i].priority + "\t\t" + ct[i] + "\t\t" + tat[i] + "\t\t" + wt[i]);
        }
        System.out.printf("\nAverage Turnaround Time: %.2f\n", avgTAT);
        System.out.printf("Average Waiting Time: %.2f\n", avgWT);
    }
}

该代码使用了静态非剥夺式优先级调度算法，其中程序会首先按照到达时间排序，然后按照进程的优先级进行排序。程序会根据这个排序顺序依次完成每个进程，并计算出每个进程的完成时间、周转时间和等待时间。最后，程序会输出每个进程的各项数据以及平均周转时间和等待时间。