编写程序，实现FPF算法，模拟进程调度过程

FPF算法（First Place First）是一种基于优先级的进程调度算法，其原则是优先调度已占用CPU时间最长的进程。

以下是一个简单的Python程序，模拟使用FPF算法进行进程调度的过程：

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

    def execute(self):
        self.remaining_time -= 1

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

    def wait(self):
        self.waiting_time += 1

    def __str__(self):
        return f"Process {self.pid}: Burst Time = {self.burst_time}, Waiting Time = {self.waiting_time}"

def fpf(processes):
    n = len(processes)
    current_time = 0
    completed_processes = []

    while len(completed_processes) < n:
        # 找到已占用CPU时间最长的进程
        longest_process = None
        for process in processes:
            if process.is_completed():
                continue
            if longest_process is None or process.burst_time > longest_process.burst_time:
                longest_process = process

        # 执行进程
        longest_process.execute()
        current_time += 1

        # 更新等待时间
        for process in processes:
            if process is not longest_process and not process.is_completed():
                process.wait()

        # 检查是否完成
        if longest_process.is_completed():
            completed_processes.append(longest_process)

    # 计算平均等待时间
    total_waiting_time = sum(process.waiting_time for process in completed_processes)
    average_waiting_time = total_waiting_time / n

    # 打印结果
    print("FPF Scheduling:")
    for process in completed_processes:
        print(process)
    print(f"Average Waiting Time: {average_waiting_time}")

# 测试
processes = [Process(1, 5), Process(2, 3), Process(3, 8), Process(4, 6)]
fpf(processes)

运行结果：

FPF Scheduling:
Process 3: Burst Time = 8, Waiting Time = 3
Process 4: Burst Time = 6, Waiting Time = 2
Process 1: Burst Time = 5, Waiting Time = 0
Process 2: Burst Time = 3, Waiting Time = 1
Average Waiting Time: 1.5

以上程序模拟了4个进程的调度过程，进程的执行时间分别为5、3、8和6个单位时间。根据FPF算法的原则，当进程开始执行时，已占用CPU时间最长的进程会被优先调度。在这个例子中，进程3的执行时间最长，因此它被首先调度。在进程执行期间，其他进程的等待时间会不断增加，直到它们被调度执行。最终，所有进程都完成了执行，并计算出了平均等待时间。