python实现操作系统pcb进程调度

该代码实现了一个基于优先级的进程调度算法。它使用了三个队列，分别是就绪队列、运行队列和阻塞队列，以模拟进程在操作系统中的状态。代码中的PCB类代表了进程控制块，它包含了优先级、时间片、pid和是否需要io等属性。PriorityAlgorithm类实现了进程的创建、进程调度、进程状态的展示等功能。

具体实现流程如下：

首先创建PriorityAlgorithm类的实例，调用该实例的print_all()方法展示当前队列中的进程状态。

接着调用wake()方法，模拟进程调度的过程。在wake()方法中，首先判断进程是否结束，如果就绪队列为空，则打印进程结束的信息并退出程序。

如果就绪队列不为空，则通过调用p_r()方法将就绪队列中优先级最大的进程插入运行队列，并将其从就绪队列中删除。然后打印当前三个队列中的进程状态。

如果阻塞队列不为空，则调用b_p()方法将阻塞队列中优先级最大的进程插入就绪队列，并将其从阻塞队列中删除。然后打印当前三个队列中的进程状态。

如果运行队列中的进程需要io，则将其转移到阻塞队列中，并打印缺少io的信息。然后将运行队列中的进程设为None，以便下次调度。如果此时就绪队列不为空，则继续调用wake()方法进行进程调度。最后打印当前三个队列中的进程状态。

如果运行队列中的进程不需要io，则通过time模块模拟进程运行的时间。运行完成后，将运行队列中的进程设为None，以便下次调度。

如果阻塞队列不为空，则调用b_p()方法将阻塞队列中优先级最大的进程插入就绪队列，并将其从阻塞队列中删除。然后打印当前三个队列中的进程状态。

最后递归调用wake()方法，以模拟进程不断调度的过程
 

代码如下：

import time
import random


class PCB:

    def __init__(self, priority, hold_time, io):

        self.priority = priority #优先级
        self.hold_time = hold_time  # 时间片
        self.pid = random.randint(1000, 9999)  # pid
        self.io = io  #是否需要io

    def __str__(self):
        return str(self.pid) + "\t" + str(self.priority) + "\t" + str(self.hold_time) + "\t\t\t\t" + \
               str('True' if self.io == 1 else 'False')


class PriorityAlgorithm:

    def __init__(self):
        self.progresses = []  # 就绪
        self.run = [None] *1# 运行
        self.block = []  # 阻塞
        self.progresses_in()  # 创建进程

    # 进程创建
    def progresses_in(self):
        n = int(input("请输入进程个数："))
        i = 0
        while i < n:
            print(f"请输入第{i + 1}个进程的信息：")
            p = int(input("请输入优先级:"))
            time = int(input("请输入运行时间："))
            io = int(input("请输入是否需要io(1:需要  0：不需要)："))
            print()
            self.progresses.append(PCB(p, time, io))
            i += 1
        return

    # 展示就绪队列
    def print_progresses(self):
        print("当前就绪队列中的进程有：")
        print(str('pid') + "\t" + str('priority')+ "\t" + \
              str('hold_time') + "\t" + \
              str('io'))
        for i in range(len(self.progresses)):
            print(self.progresses[i])

    # 展示运行队列
    def print_run(self):
        print("当前运行队列中的进程有：")
        print(str('pid') + "\t" + str('priority')  + "\t" + \
              str('hold_time') + "\t" + \
              str('io'))
        print(self.run[0])

    # 展示阻塞队列
    def print_block(self):
        print("当前阻塞队列中的进程有：")
        print(str('pid') + "\t" + str('priority') + "\t" + \
              str('hold_time') + "\t" + \
              str('io'))
        for i in range(len(self.block)):
            print(self.block[i])

    #打印所有队列
    def print_all(self):
        self.print_run()
        self.print_progresses()
        self.print_block()
        print()

    #进程调度
    def wake(self):
        #结束条件
        if len(self.progresses) == 0:
            print("进程结束！")
            exit(0)
        self.p_r()
        self.print_all()
        if len(self.block) != 0:
            self.b_p()
            self.print_all()
        if self.run[0].io == True:
            self.run[0].io = False
            print("缺少该进程需要的io！将其转入阻塞队列！！！")
            print()
            self.r_b()
            self.run[0] = None
            if len(self.progresses) != 0:
                self.wake()
            self.print_all()
        else:
            time.sleep(self.run[0].hold_time)
            print(f"进程,pid为：{self.run[0].pid}运行：{self.run[0].hold_time}秒，时间片结束！！")
            print()
            self.run[0] = None
        if len(self.block) != 0:
            self.b_p()
            self.print_all()
        self.wake()

    def p_r(self):
        #取得最大优先级的下标
        index = 0
        max_pri = self.progresses[0].priority
        for i in range(len(self.progresses)):
            if self.progresses[i].priority > max_pri:
                index = i
                max_pri = self.progresses[i].priority
        #将最大优先级插入运行队列
        self.run[0] = self.progresses[index]
        self.progresses.pop(index)

    #运行到阻塞
    def r_b(self):
        self.block.append(self.run[0])

    def b_p(self):
        # 取得最大优先级的下标
        index = 0
        max_pri = self.block[0].priority
        for i in range(len(self.block)):
            if self.block[i].priority > max_pri:
                index = i
                max_pri = self.block[i].priority
        self.progresses.append(self.block[index])
        self.block.pop(index)


if __name__ == '__main__':
    p = PriorityAlgorithm()
    p.print_all()
    p.wake()