进程调度模拟设计（非抢占式短进程优先算法、线性优先级法）

具体要求如下：

• 能够输入进程的基本信息，如进程名、到达时间、预估运行时间等；
• 能够选择不同的调度算法；
• 根据选择的调度算法显示进程调度顺序；
• 显示完成调度后每个进程的开始时间、完成时间、周转时间、带权周转时间；
• 计算平均周转时间和平均带权周转时间。

 

class PCB(object):
    def __init__(self, name, priority, arrive_time, run_time):
        self.name = name  # 进程名
        self.priority = priority  # 优先级
        self.arrive_time = arrive_time  # 到达时间
        self.start_time = 999999  # 开始时间，方便取最小值更新
        self.finish_time = 0  # 完成时间
        self.run_time = run_time  # 预估运行时间
        self.rund_time = 0  # 已运行时间
        self.zztime = 0  # 周转时间
        self.dqzztime = 0  # 带权周转时间


class processor(object):
    def __init__(self, queue):
        self.size = 2  # 时间片大小
        self.count = 0  # 计时器
        self.queue = queue  # 未提交进程队列
        self.queue_a = []  # 新创建进程队列
        self.queue_b = []  # 享受服务进程队列
        self.finish_queue = []  # 运行完进程队列
        self.a = 2  # 队列a优先级增长速率
        self.b = 1  # 队列a优先级增长速率
        self.sequence = []  # 处理顺序
        self.pjzztime = 0  # 平局周转时间
        self.pjdqzztime = 0  # 带权周转时间

    def SJF(self):
        self.finish_queue = []  # 已完成进程队列
        self.queue.sort(key=lambda x: x.arrive_time)  # 未提交进程队列
        while (self.queue != [] or self.queue_a != []):  # 各进程队列不为空则继续运行

            for process in self.queue:  # 判断有无新进程提交到就绪队列
                if self.queue != [] and process.arrive_time <= self.count:
                    self.queue_a.append(self.queue.pop(0))

            if self.queue_a != []:  # 如果有就绪进程
                self.queue_a.sort(key=lambda x: x.run_time)  # 最短进程排序
                process = self.queue_a.pop(0)
                self.finish_queue.append(process)  # 完成该进程
                process.start_time = self.count  # 记录进程信息
                process.finish_time = self.count + process.run_time
                process.zztime = process.finish_time - process.arrive_time
                process.dqzztime = process.zztime / process.run_time
                self.count = process.finish_time  # 添加到处理序列
                self.sequence.append(process.name)
            else:
                self.count += 1  # 处理机空闲
        # 周转时间
        self.pjzztime = sum(process.zztime for process in self.finish_queue) / len(self.finish_queue)
        # 带权周转时间
        self.pjdqzztime = sum(process.dqzztime for process in self.finish_queue) / len(self.finish_queue)

    def SRR(self):
        self.finish_queue = []  # 运行完成进程队列
        self.queue = sorted(self.queue, key=lambda x: x.arrive_time)  # 未提交进程队列
        while(self.queue_b != [] or self.queue != [] or self.queue_a != []):  # 有进程未完成
            time_size = 1  # 当前回合的时间跨度

            while self.queue != [] and self.count >= self.queue[0].arrive_time:  # 有进程到达队列a
                self.queue_a.append(self.queue.pop(0))

            while self.queue_a != [] and (self.queue_b == [] or self.queue_a[0].priority >= self.queue_b[-1].priority):  # 队列a有进程进入队列b
                self.queue_b.append(self.queue_a.pop(0))

            if self.queue_b != []:  # 服务队列不为空
                #print(self.count,self.queue_b[0].name, self.queue_b[0].priority, len(self.queue), len(self.queue_a), len(self.queue_b))
                self.sequence.append(self.queue_b[0].name)  # 加入执行顺序
                if self.queue_b[0].rund_time + self.size < self.queue_b[0].run_time:  # 时间片能用完,进程未结束
                    self.queue_b[0].rund_time += self.size  # 进程信息记录
                    self.queue_b[0].start_time = min(self.queue_b[0].start_time, self.count)
                    self.count += self.size  # 处理机计时器更新
                    time_size = self.size
                else:                            # 时间片用不完或刚好用完，进程能结束
                    time_size = self.queue_b[0].run_time - self.queue_b[0].rund_time
                    self.queue_b[0].rund_time = self.queue_b[0].run_time  # 进程信息记录
                    self.queue_b[0].start_time = min(self.queue_b[0].start_time, self.count)
                    self.count += time_size  # 处理机计时器更新
                    self.queue_b[0].finish_time = self.count
                    self.queue_b[0].zztime = self.queue_b[0].finish_time - self.queue_b[0].arrive_time
                    self.queue_b[0].dqzztime = self.queue_b[0].zztime / self.queue_b[0].run_time

                if self.queue_b[0].run_time == self.queue_b[0].rund_time:  # 进程运行完成则回收
                    self.finish_queue.append(self.queue_b[0])
                    self.queue_b.remove(self.queue_b[0])
                else:
                    p = self.queue_b.pop(0)  # 否则进入队列b尾部排队
                    self.queue_b.append(p)
            else:
                self.count += 1    # 处理机空闲，# 处理机计时器更新

            for process in self.queue_b:  # 优先级更新
                process.priority += self.b * time_size
            for process in self.queue_a:  # 优先级更新
                process.priority += self.a * time_size

        self.pjzztime = sum(process.zztime for process in self.finish_queue) / len(self.finish_queue)
        self.pjdqzztime = sum(process.dqzztime for process in self.finish_queue) / len(self.finish_queue)


processes = [PCB('p1', 0, 4, 4),PCB('p2', 0, 4, 2),PCB('p3', 0, 2, 8),PCB('p4', 0, 2, 6)]
processor = processor(processes)
#processor.SJF()  # 手动选择
processor.SRR()
print('进程名     开始时间      结束时间     周转时间     带权周转时间')
for process in processor.finish_queue:
    print(process.name, end='\t\t\t')
    print(process.start_time, end='\t\t\t')
    print(process.finish_time, end='\t\t\t')
    print(process.zztime, end='\t\t\t')
    print(process.dqzztime)
print('平均周转时间：' + str(processor.pjzztime))
print('平均带权周转时间：' + str(processor.pjdqzztime))
print('调度顺序：')
print(processor.sequence)



'''
processes = []
n = int(input('输入进程个数:'))
for i in range(n):
    x1 = input(str(i+1)+'输入程名：')
    x2 = int(input(str(i+1)+'输入进程优先级：'))
    x3 = int(input(str(i+1)+'输入进程到达时间：'))
    x4 = int(input(str(i+1)+'输入进程运行时间：'))
    processes.append(PCB(x1, x2, x3, x4))

processor = processor(processes)
n = int(input('选择算法：1.SJF   2.SRR'))
if n == 1:
    processor.SJF()
else:
    processor.SRR()

print('进程名     开始时间      结束时间     周转时间     带权周转时间')
for process in processor.finish_queue:
    print(process.name, end='\t\t\t')
    print(process.start_time, end='\t\t\t')
    print(process.finish_time, end='\t\t\t')
    print(process.zztime, end='\t\t\t')
    print(process.dqzztime)
print('平均周转时间：' + str(processor.pjzztime))
print('平均带权周转时间：' + str(processor.pjdqzztime))
print('调度顺序：')
print(processor.sequence)
'''