优先数法和简单轮转法实验

优先数法和简单轮转法是常用的进程调度算法。下面是一个基于Python的简单实验，展示这两种算法的基本实现。

优先数法实验代码：

# 优先数法实验
class Process:
    def __init__(self, pid, burst_time, priority):
        self.pid = pid
        self.burst_time = burst_time
        self.priority = priority
        self.waiting_time = 0
        self.turnaround_time = 0

def find_waiting_time(processes, n):
    waiting_time = [0] * n
    waiting_time[0] = 0
    for i in range(1, n):
        waiting_time[i] = processes[i - 1].burst_time + waiting_time[i - 1]
    return waiting_time

def find_turnaround_time(processes, n, waiting_time):
    turnaround_time = [0] * n
    for i in range(n):
        turnaround_time[i] = processes[i].burst_time + waiting_time[i]
    return turnaround_time

def find_avg_time(processes, n):
    waiting_time = find_waiting_time(processes, n)
    turnaround_time = find_turnaround_time(processes, n, waiting_time)
    total_waiting_time = sum(waiting_time)
    total_turnaround_time = sum(turnaround_time)
    avg_waiting_time = round(total_waiting_time / n, 2)
    avg_turnaround_time = round(total_turnaround_time / n, 2)
    return avg_waiting_time, avg_turnaround_time

def priority_scheduling(processes, n):
    processes.sort(key=lambda x: x.priority)
    avg_waiting_time, avg_turnaround_time = find_avg_time(processes, n)
    print("Process ID\tBurst Time\tPriority\tWaiting Time\tTurnaround Time")
    for i in range(n):
        print(f"{processes[i].pid}\t\t{processes[i].burst_time}\t\t{processes[i].priority}\t\t{processes[i].waiting_time}\t\t{processes[i].turnaround_time}")
    print(f"Avg Waiting Time: {avg_waiting_time}")
    print(f"Avg Turnaround Time: {avg_turnaround_time}")

if __name__ == "__main__":
    processes = [
        Process(1, 10, 3),
        Process(2, 5, 1),
        Process(3, 8, 2),
        Process(4, 7, 4),
        Process(5, 2, 5)
    ]
    n = len(processes)
    priority_scheduling(processes, n)

简单轮转法实验代码：

# 简单轮转法实验
class Process:
    def __init__(self, pid, burst_time):
        self.pid = pid
        self.burst_time = burst_time
        self.waiting_time = 0
        self.turnaround_time = 0

def find_waiting_time(processes, n, quantum):
    remaining_time = [p.burst_time for p in processes]
    t = 0
    while True:
        done = True
        for i in range(n):
            if remaining_time[i] > 0:
                done = False
                if remaining_time[i] > quantum:
                    t += quantum
                    remaining_time[i] -= quantum
                else:
                    t += remaining_time[i]
                    processes[i].waiting_time = t - processes[i].burst_time
                    remaining_time[i] = 0
        if done:
            break

def find_turnaround_time(processes, n):
    for i in range(n):
        processes[i].turnaround_time = processes[i].burst_time + processes[i].waiting_time

def find_avg_time(processes, n):
    total_waiting_time = sum(p.waiting_time for p in processes)
    total_turnaround_time = sum(p.turnaround_time for p in processes)
    avg_waiting_time = round(total_waiting_time / n, 2)
    avg_turnaround_time = round(total_turnaround_time / n, 2)
    return avg_waiting_time, avg_turnaround_time

def round_robin_scheduling(processes, n, quantum):
    find_waiting_time(processes, n, quantum)
    find_turnaround_time(processes, n)
    avg_waiting_time, avg_turnaround_time = find_avg_time(processes, n)
    print("Process ID\tBurst Time\tWaiting Time\tTurnaround Time")
    for i in range(n):
        print(f"{processes[i].pid}\t\t{processes[i].burst_time}\t\t{processes[i].waiting_time}\t\t{processes[i].turnaround_time}")
    print(f"Avg Waiting Time: {avg_waiting_time}")
    print(f"Avg Turnaround Time: {avg_turnaround_time}")

if __name__ == "__main__":
    processes = [
        Process(1, 10),
        Process(2, 5),
        Process(3, 8),
        Process(4, 7),
        Process(5, 2)
    ]
    quantum = 2
    n = len(processes)
    round_robin_scheduling(processes, n, quantum)

在这个实验中，我们创建了一个Process类来表示进程，包含进程ID、运行时间、优先级、等待时间和周转时间等属性。优先数法实现中，我们使用Python的sort()函数来根据进程的优先级对进程列表进行排序。简单轮转法实现中，我们使用了一个while循环来模拟进程的轮流调度，直到所有进程都完成为止。

最后，我们通过调用相应的函数来运行这两种算法的实验，并打印出每个进程的等待时间和周转时间，以及平均等待时间和平均周转时间。