进程调度算法 python实现

进程调度算法是用来管理计算机系统中并发运行的进程，决定哪个进程应该获得处理器的时间片。Python作为一种高级语言，可以用来实现各种调度策略，比如先来先服务(FIFO)、短进程优先(SJF)、优先级反转(RR)、轮转(RR)等。下面简单概述一下几种常见的调度算法在Python中的基本实现：

1. **FIFO (First-First-Out)**: 按照进程到达时间顺序执行，可以利用Python的`queue`模块（如`queue.PriorityQueue`）来模拟。

import queue

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

def fifo_scheduler(processes):
    q = queue.Queue()
    for p in processes:
        q.put(p)
    while not q.empty():
        process = q.get()
        print(f"Process {process.id} running for {process.burst_time} time slices")

2. **SJF (Shortest Job First)**: 根据每个进程的剩余执行时间选择最短的进程。这需要维护一个堆数据结构（可以用`heapq`模块），每次从队列头部取出执行时间最短的进程。

import heapq

def sjf_scheduler(processes):
    heap = []
    for p in processes:
        heapq.heappush(heap, (p.burst_time, p))
    while heap:
        process = heapq.heappop(heap)[1]
        print(f"Process {process.id} running for {process.burst_time} time slices")

3. **RR (Round Robin)**: 定期轮换执行，可以结合计数器实现。这里仅提供核心思路，实际应用需要处理循环等待和定时器。

def rr_scheduler(processes, quantum):
    current_process = None
    for _ in range(len(processes)):
        if current_process is None:
            # 初始化或找到第一个进程
            current_process = processes[0]
        else:
            # 轮转
            current_process = next((p for p in processes if p != current_process), None)

        if current_process:
            print(f"Process {current_process.id} running for {quantum} time slices")
            current_process.burst_time -= quantum
            if current_process.burst_time == 0:
                current_process = None