编程模拟实现进程调度算法（RR时间片轮转与HPF优先级调度算法

RR时间片轮转算法的实现：

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

    def execute(self, time_quantum):
        if self.remaining_time <= time_quantum:
            executed_time = self.remaining_time
            self.remaining_time = 0
        else:
            executed_time = time_quantum
            self.remaining_time -= time_quantum
        return executed_time

    def is_completed(self):
        return self.remaining_time == 0

class RoundRobinScheduler:
    def __init__(self, processes, time_quantum):
        self.processes = processes
        self.time_quantum = time_quantum
        self.queue = []

    def execute(self):
        current_time = 0
        while True:
            # Add arriving processes to the queue
            for process in self.processes:
                if process.burst_time > 0 and process not in self.queue:
                    self.queue.append(process)

            # If all processes have completed, exit the loop
            if len(self.queue) == 0:
                break

            # Get the first process in the queue
            process = self.queue.pop(0)

            # Execute the process for the time quantum
            executed_time = process.execute(self.time_quantum)
            current_time += executed_time

            # If the process is not completed, add it back to the queue
            if not process.is_completed():
                self.queue.append(process)

        return current_time

HPF优先级调度算法的实现：

class PriorityScheduler:
    def __init__(self, processes):
        self.processes = processes
        self.queue = []

    def execute(self):
        current_time = 0
        while True:
            # Add arriving processes to the queue
            for process in self.processes:
                if process.burst_time > 0 and process not in self.queue:
                    self.queue.append(process)

            # If all processes have completed, exit the loop
            if len(self.queue) == 0:
                break

            # Sort the queue by priority
            self.queue.sort(key=lambda x: x.priority, reverse=True)

            # Get the highest-priority process in the queue
            process = self.queue.pop(0)

            # Execute the process
            executed_time = process.execute(process.burst_time)
            current_time += executed_time

        return current_time

注意：需要在 `Process` 类中添加一个 `priority` 属性来表示进程的优先级。