python先到先得调度和轮询调度

根据这个python代码写一个先到先得和轮询cpu 调度（fcfs and round robin scheduling，用于计算每一个进程的等待时间，以及所有进程的平均等待时间，不需要提供Gantt chart 和 turnaround time（不使用） 。输出结果只需要每一个进程的等待时间，以及所有进程的平均等待时间即可。不能改变提供的代码，不能使用lambda（尽量使用简单的方式完成，原创（代码查重））

程序如下

def alg_fcfs(processes, n):
    total_wtime = 0
    finish_time = 0 #这个表示当前进程结束的时候，是下个进程可以被执行的开始时间
    for i in range(n):
        if i == 0: #如果是第一个就立马执行了
            wait_time = 0
        else:
            #wait_time = 可以进行新的计算开始时间finish_time - 进程进入时间processes[i][1]
            wait_time = finish_time - processes[i][1]
            if wait_time < 0: #如果小于等于0说明当前进程不需要等待直接执行了
                wait_time = 0
        #这个表示当前进程结束的时间，是下个进程可以被执行的开始时间
        #比如进程0进来时间是1，执行时间是2，等待时间是2，那么finish_time=1+2+2=5，是下个进程能够被执行的时间
        finish_time = processes[i][1] + processes[i][2] + wait_time
        total_wtime += wait_time
        print(f'Process: {processes[i][0]}, wait time: {wait_time}')
    print('average wait time of processes:{0:.2f}'.format(total_wtime/n))

def alg_rr(processes, n, unit_time):
    #总的思想是，经过一个轮询后，更新每一个进程下一轮进入的时间和还剩下多少时间没有处理完
    #如果进程处理完了就不参与计算，直到所有进程处理完成
    waits_time=[0 for i in range(n)] #初始化每个进程的等待时间，每一轮询需要累加等待时间
    total_wtime = 0
    finish_time = 0
    while True:#表示只要有一个进程没有被处理完就继续处理
        finished = True #True表示进程都处理完，退出循环
        for i in range(n):
            if processes[i][2] == 0: #processes[i][2]表示需要执行的时间，如果为0，说明是执行完毕，不需要再处理
                continue
            #这里的finish_time类似 fcfs 方法里面的理解，下面的思路和fcfs里面基本一致
            wait_time = finish_time - processes[i][1]
            if wait_time < 0:
                wait_time = 0
            waits_time[i] += wait_time
            finish_time = processes[i][1] + unit_time + wait_time
            #processes[i][1]更新进程一个轮询后下一个进入等待的时间类似进入时间
            processes[i][1] = finish_time
            #processes[i][2]更新进程一个轮询后还剩下多少没有执行完，如果小于等于0，说明执行完成
            processes[i][2] -= unit_time
            if processes[i][2] < 0:
                processes[i][2] = 0
            finished = False
        if finished:
            break
    total_wtime=0
    for i in range(n):
        print(f'Process: {processes[i][0]}, wait time: {waits_time[i]}')
        total_wtime+=waits_time[i]
    print('average wait time of processes:{0:.2f}'.format(total_wtime / n))

n = int(input("The number of processes:"))
processes = []
for _ in range(n):
    p, a, b = map(int, input().split())
    processes.append([p, a, b])
print(processes)

print("-----------alg fcfs:------------")
alg_fcfs(processes, n)
print("-----------alg rr:--------------")
alg_rr(processes, n, 2) #假设单个轮询时间是2个单位

参考下

您可以使用两种不同的调度策略来计算每个进程的等待时间和所有进程的平均等待时间，分别是先来先服务（FCFS）和时间片轮转（Round Robin）。

先来先服务（FCFS）:

创建一个等待时间列表，并初始化为0。
将进程按到达时间排序。
循环遍历每个进程，计算等待时间：等待时间 = 前一个进程完成时间 - 当前进程到达时间 + 当前进程的服务时间。
求出所有进程的平均等待时间。
时间片轮转（Round Robin）:

创建一个等待时间列表，并初始化为0。
将进程按到达时间排序。
循环遍历每个进程，每次运行时间片长度。
如果进程完成，则计算等待时间：等待时间 = 当前时间 - 当前进程到达时间 + 当前进程的服务时间。
求出所有进程的平均等待时间。
输出结果只需要每一个进程的等待时间，以及所有进程的平均等待时间。

调度算法

# FCFS Scheduling

# sort the processes by arrival time
processes.sort(key=lambda x: x[1])

# calculate waiting time for each process
waiting_times = []
total_waiting_time = 0
for i in range(n):
    if i == 0:
        waiting_times.append(0)
    else:
        waiting_times.append(processes[i-1][2] + waiting_times[i-1] - processes[i][1])
    total_waiting_time += waiting_times[i]

# calculate average waiting time
average_waiting_time = total_waiting_time / n

# print the waiting time for each process
print("Waiting times for each process:", waiting_times)
print("Average waiting time:", average_waiting_time)

轮询（Round Robin）调度算法

# Round Robin Scheduling

# set time quantum
time_quantum = int(input("Enter time quantum: "))

# copy the original processes list
temp_processes = processes.copy()

# initialize variables
waiting_times = [0] * n
turnaround_times = [0] * n
total_waiting_time = 0
total_turnaround_time = 0

# start the scheduling
time = 0
while len(temp_processes) > 0:
    # get the next process
    next_process = None
    for i in range(len(temp_processes)):
        if temp_processes[i][1] <= time:
            next_process = temp_processes[i]
            break
    if next_process is None:
        time += 1
        continue
    temp_processes.remove(next_process)

    # update waiting times
    for i in range(n):
        if processes[i][0] == next_process[0]:
            waiting_times[i] = time - processes[i][1]

    # update turnaround times
    for i in range(n):
        if processes[i][0] == next_process[0]:
            turnaround_times[i] = waiting_times[i] + processes[i][2]

    # update total waiting and turnaround times
    total_waiting_time += waiting_times[i]
    total_turnaround_time += turnaround_times[i]

    # update time
    time += min(time_quantum, next_process[2])

# calculate average waiting and turnaround times
average_waiting_time = total_waiting_time / n
average_turnaround_time = total_turnaround_time / n

# print the waiting time for each process
print("Waiting times for each process:", waiting_times)
print("Average waiting time:", average_waiting_time)