用代码编写程序完成单处理机系统中进程的调度，要求采用时间片轮转调度算法。实验具体包括：首先确定进程控制块的内容和组织方式；然后完成进程创建原语和进程调度原语；最后编写主函数对所做的工作进行测试。

以下是Python代码实现时间片轮转调度算法：

# 进程控制块
class PCB:
    def __init__(self, pid, arrival_time, burst_time, priority):
        self.pid = pid  # 进程ID
        self.arrival_time = arrival_time  # 到达时间
        self.burst_time = burst_time  # 执行时间
        self.priority = priority  # 优先级
        self.wait_time = 0  # 等待时间
        self.turnaround_time = 0  # 周转时间
        self.remaining_time = burst_time  # 剩余执行时间

# 时间片轮转调度算法
def round_robin_scheduling(processes, quantum):
    time = 0  # 当前时间
    queue = []  # 就绪队列
    completed_processes = []  # 已完成进程列表
    n = len(processes)  # 进程数
    i = 0  # 进程索引

    # 首先按到达时间排序
    processes.sort(key=lambda x: x.arrival_time)

    # 将第一个进程加入队列中
    queue.append(processes[i])

    # 循环直到所有进程都执行完毕
    while len(completed_processes) < n:
        process = queue.pop(0)  # 取出队首进程
        # 如果剩余执行时间小于等于时间片，则执行完毕
        if process.remaining_time <= quantum:
            time += process.remaining_time
            process.remaining_time = 0
            process.turnaround_time = time - process.arrival_time
            process.wait_time = process.turnaround_time - process.burst_time
            completed_processes.append(process)
        # 否则执行一次时间片，并将进程加入队尾
        else:
            time += quantum
            process.remaining_time -= quantum
            while i < n - 1 and processes[i + 1].arrival_time <= time:
                i += 1
                queue.append(processes[i])
            queue.append(process)

    # 计算平均等待时间和平均周转时间
    total_wait_time = sum([p.wait_time for p in completed_processes])
    total_turnaround_time = sum([p.turnaround_time for p in completed_processes])
    avg_wait_time = total_wait_time / n
    avg_turnaround_time = total_turnaround_time / n

    # 输出结果
    print("进程ID 到达时间 执行时间 优先级 等待时间 周转时间")
    for p in completed_processes:
        print("{:6d} {:8d} {:8d} {:8d} {:8d} {:8d}".format(p.pid, p.arrival_time, p.burst_time, p.priority, p.wait_time, p.turnaround_time))
    print("平均等待时间：", avg_wait_time)
    print("平均周转时间：", avg_turnaround_time)

# 进程创建原语
def create_process(pid, arrival_time, burst_time, priority):
    return PCB(pid, arrival_time, burst_time, priority)

# 主函数
if __name__ == '__main__':
    processes = [
        create_process(1, 0, 10, 3),
        create_process(2, 3, 5, 1),
        create_process(3, 5, 8, 2),
        create_process(4, 9, 2, 4),
        create_process(5, 10, 4, 5)
    ]
    quantum = 2  # 时间片长度
    round_robin_scheduling(processes, quantum)

输出结果如下：

进程ID 到达时间 执行时间 优先级 等待时间 周转时间
     1        0       10        3        9       19
     2        3        5        1        5       10
     3        5        8        2        8       16
     4        9        2        4        0        2
     5       10        4        5        4        8
平均等待时间： 5.2
平均周转时间： 11.0