用python写出进程调度模拟系统，包括轮转算法，优先级调度算法，最短进程优先算法

以下是一个简单的进程调度模拟系统，包括轮转算法、优先级调度算法和最短进程优先算法的实现。需要注意的是，这只是一个简单的模拟，实际应用中还需要考虑更多的因素，如进程的状态转换、IO等待等等。另外，这里使用了Python的Queue模块来模拟进程队列。

from queue import Queue

class Process:
    def __init__(self, pid, burst_time, priority):
        self.pid = pid
        self.burst_time = burst_time
        self.priority = priority

    def __str__(self):
        return f"Process {self.pid} - Burst Time: {self.burst_time}, Priority: {self.priority}"

class Scheduler:
    def __init__(self, processes):
        self.processes = processes
        self.ready_queue = Queue()
        self.time_slice = 3 # 轮转算法的时间片长度
        self.current_time = 0

    def schedule(self):
        self.sort_by_priority() # 优先级调度算法
        #self.sort_by_burst_time() # 最短进程优先算法

        while not self.all_done():
            self.add_to_queue()
            if not self.ready_queue.empty():
                current_process = self.ready_queue.get()
                self.run_process(current_process)
                self.update_time(current_process)

    def sort_by_priority(self):
        self.processes.sort(key=lambda p: p.priority, reverse=True)

    def sort_by_burst_time(self):
        self.processes.sort(key=lambda p: p.burst_time)

    def add_to_queue(self):
        for process in self.processes:
            if process.burst_time > 0 and process not in list(self.ready_queue.queue):
                self.ready_queue.put(process)

    def run_process(self, process):
        print(f"Time {self.current_time}: Running {process}")
        process.burst_time -= self.time_slice

    def update_time(self, process):
        self.current_time += self.time_slice
        if process.burst_time > 0:
            self.ready_queue.put(process)

    def all_done(self):
        return all(p.burst_time == 0 for p in self.processes)


if __name__ == '__main__':
    processes = [
        Process(1, 10, 2),
        Process(2, 5, 1),
        Process(3, 8, 3),
        Process(4, 4, 4),
    ]

    scheduler = Scheduler(processes)
    scheduler.schedule()

在上面的代码中，我们首先定义了一个Process类，表示进程。每个进程有一个pid（进程ID）、burst_time（CPU占用时间）和priority（优先级）属性。然后定义了一个Scheduler类，表示调度器。调度器中有一个ready_queue队列，用于存放就绪进程。我们实现了三个方法来实现不同的调度算法，即sort_by_priority方法（优先级调度算法）、sort_by_burst_time方法（最短进程优先算法）和add_to_queue方法（轮转算法）。在schedule方法中，我们先调用了sort_by_priority方法，然后在一个循环中，不断将就绪进程加入队列中，并运行队首的进程。在运行进程时，我们输出了当前时间和正在运行的进程，然后将进程的CPU占用时间减去时间片长度。在更新时间时，如果进程的CPU占用时间仍然大于0，则将其重新加入队列中。当所有进程的CPU占用时间都为0时，我们就结束了调度。

在上面的代码中，默认使用了轮转算法，如果要使用其他算法，只需要将sort_by_priority方法或sort_by_burst_time方法的注释取消，并将add_to_queue方法的注释打开即可。