用python实现基于优先数的进程调度(HPF)算法

下面是一个实现基于优先数的进程调度(HPF)算法的Python代码：

class Process:
    def __init__(self, pid, priority, arrival_time, burst_time):
        self.pid = pid
        self.priority = priority
        self.arrival_time = arrival_time
        self.burst_time = burst_time
        self.waiting_time = 0
        self.turnaround_time = 0

    def __str__(self):
        return f"Process {self.pid}"

class HPFScheduler:
    def __init__(self, processes):
        self.processes = processes
        self.current_time = 0
        self.completed_processes = []
        self.ready_queue = []

    def schedule(self):
        while self.processes or self.ready_queue:
            # Add newly arrived processes to the ready queue
            for process in self.processes:
                if process.arrival_time <= self.current_time:
                    self.ready_queue.append(process)
            
            self.processes = [process for process in self.processes if process not in self.ready_queue]

            if not self.ready_queue:
                # If there are no processes in the ready queue, increment current time
                self.current_time += 1
                continue

            # Sort the ready queue based on priority
            self.ready_queue.sort(key=lambda x: x.priority, reverse=True)

            # Execute the process with highest priority
            current_process = self.ready_queue.pop(0)
            current_process.waiting_time = self.current_time - current_process.arrival_time
            self.current_time += current_process.burst_time
            current_process.turnaround_time = self.current_time - current_process.arrival_time
            self.completed_processes.append(current_process)

        # Calculate average waiting time and turnaround time
        waiting_times = [process.waiting_time for process in self.completed_processes]
        average_waiting_time = sum(waiting_times) / len(waiting_times)

        turnaround_times = [process.turnaround_time for process in self.completed_processes]
        average_turnaround_time = sum(turnaround_times) / len(turnaround_times)

        print(f"Average waiting time: {average_waiting_time}")
        print(f"Average turnaround time: {average_turnaround_time}")

这个代码中，`Process` 类表示一个进程，`HPFScheduler` 类表示一个基于优先数的进程调度器。`processes` 参数是一个包含所有进程的列表。`schedule` 方法实现了调度算法，会将每个进程加入就绪队列并进行排序，然后选择优先级最高的进程执行。执行完一个进程后，会计算它的等待时间和周转时间，并将它加入已完成进程列表。最后，会计算所有进程的平均等待时间和平均周转时间，并输出结果。

你可以按照以下方式使用这个代码：

# Create a list of processes
processes = [
    Process(1, 3, 0, 5),
    Process(2, 1, 1, 3),
    Process(3, 4, 2, 2),
    Process(4, 2, 3, 1),
    Process(5, 5, 4, 4)
]

# Create a scheduler and schedule the processes
scheduler = HPFScheduler(processes)
scheduler.schedule()

这个例子中包含了5个进程，它们的优先级、到达时间和执行时间分别是：

| 进程 | 优先级 | 到达时间 | 执行时间 |
|------|--------|----------|----------|
| 1 | 3 | 0 | 5 |
| 2 | 1 | 1 | 3 |
| 3 | 4 | 2 | 2 |
| 4 | 2 | 3 | 1 |
| 5 | 5 | 4 | 4 |

在这个例子中，进程 1 有最高的优先级，因此会先执行。接下来，会按照优先级顺序执行其他进程。最后，会输出平均等待时间和平均周转时间。