使用Python编写简单的PS（进程调度）模拟程序
```python
import heapq
class Process:
def __init__(self, pid, arrival_time, burst_time):
self.pid = pid
self.arrival_time = arrival_time
self.burst_time = burst_time
self.remaining_time = burst_time
def __lt__(self, other):
return self.burst_time < other.burst_time
def simulate_ps(processes):
processes.sort(key=lambda x: x.arrival_time) 按到达时间排序
current_time = 0
ready_queue = []
heapq.heapify(ready_queue)
completed_processes = []
while processes or ready_queue:
while processes and processes[0].arrival_time <= current_time:
process = processes.pop(0)
heapq.heappush(ready_queue, process)
if ready_queue:
running_process = heapq.heappop(ready_queue)
print(f"Process {running_process.pid} is running at time {current_time}")
running_process.remaining_time = 1
current_time = 1
if running_process.remaining_time == 0:
print(f"Process {running_process.pid} completed at time {current_time}")
completed_processes.append(running_process)
else:
heapq.heappush(ready_queue, running_process)
else:
current_time = 1
return completed_processes
if __name__ == "__main__":
示例进程列表：(pid, arrival_time, burst_time)
processes = [
Process(1, 0, 5),
Process(2, 1, 3),
Process(3, 2, 6),
Process(4, 3, 4),
]
completed_processes = simulate_ps(processes)
print("\nProcess execution order:")
for process in completed_processes:
print(f"Process {process.pid}")
```
这个Python程序模拟了一个简单的进程调度（PS）系统。它包含了一个进程类 `Process` 和一个函数 `simulate_ps` 来模拟进程的调度过程。
在模拟中，我们假设有一系列进程，每个进程有一个到达时间和一个执行时间。我们通过优先队列来模拟就绪队列，按照进程的到达时间进行排序。我们在每个时间步中，选择就绪队列中剩余执行时间最短的进程来运行。如果就绪队列为空，我们就简单地让时间流逝。
程序打印出了每个进程的执行顺序。
