时间片轮转调度算法的模拟实现

时间片轮转调度算法是一种常见的进程调度算法，可以保证所有进程公平地分配CPU时间。下面是一个时间片轮转调度算法的模拟实现示例：

class Process:
    def __init__(self, pid, burst_time, arrival_time):
        self.pid = pid
        self.burst_time = burst_time    # 进程需要的CPU时间
        self.arrival_time = arrival_time    # 进程到达时间
        self.remaining_time = burst_time    # 进程剩余需要的CPU时间
        self.waiting_time = 0    # 进程等待时间
        self.turnaround_time = 0    # 进程周转时间

    def run(self, time_slice):
        if self.remaining_time <= time_slice:
            # 如果进程剩余需要的时间小于等于时间片，则执行完
            self.waiting_time += time_slice - self.remaining_time
            self.remaining_time = 0
        else:
            # 如果进程剩余需要的时间大于时间片，则执行时间片长度
            self.waiting_time += time_slice
            self.remaining_time -= time_slice

    def __str__(self):
        return f"Process {self.pid}: burst_time={self.burst_time}, arrival_time={self.arrival_time}, waiting_time={self.waiting_time}, turnaround_time={self.turnaround_time}"

def round_robin(processes, time_slice):
    ready_queue = []    # 就绪队列
    current_time = 0    # 当前时间

    # 将所有进程按照到达时间排序，并加入就绪队列
    for process in sorted(processes, key=lambda p: p.arrival_time):
        ready_queue.append(process)

    # 进行时间片轮转调度
    while ready_queue:
        current_process = ready_queue.pop(0)
        current_process.run(time_slice)
        current_time += time_slice

        # 将执行完的进程从队列中移除，并更新进程的状态
        if current_process.remaining_time == 0:
            current_process.turnaround_time = current_time - current_process.arrival_time
            print(current_process)
        else:
            ready_queue.append(current_process)

    # 计算平均等待时间和平均周转时间
    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 = total_waiting_time / len(processes)
    avg_turnaround_time = total_turnaround_time / len(processes)
    print(f"Average waiting time: {avg_waiting_time:.2f}")
    print(f"Average turnaround time: {avg_turnaround_time:.2f}")

# 测试
processes = [
    Process(1, 5, 0),
    Process(2, 7, 2),
    Process(3, 4, 4),
]
round_robin(processes, 2)

在上面的示例中，我们定义了一个`Process`类来表示进程，并实现了时间片轮转调度算法。在执行算法的过程中，我们先将所有进程按照到达时间排序，并加入就绪队列。然后，我们不断从就绪队列中取出进程，执行时间片长度，并根据进程剩余需要的CPU时间将进程重新加入就绪队列或者移除队列。在执行完所有进程后，我们计算每个进程的平均等待时间和平均周转时间，并输出结果。