由五中的源程序，编写该代码的实验步骤和设计思路

### 实验步骤

1. **准备环境**:
- 确保使用的是Windows操作系统。
- 安装Python编程语言。
- 使用PyCharm作为开发环境。

2. **创建项目**:
- 在PyCharm中创建一个新的Python项目。
- 创建一个名为`测试.py`的Python文件。

3. **编写代码**:
- 复制并粘贴以下代码到`测试.py`文件中：

     import random

     class Pcb:
         def __init__(self, pro, priority, arrive_time, all_time, cpu_time, start_block_time, block_time, state):
             self.pro = pro
             self.priority = priority
             self.arrive_time = arrive_time
             self.all_time = all_time
             self.cpu_time = cpu_time
             self.start_block_time = start_block_time
             self.block_time = block_time
             self.state = state

         def output1(self):
             print(f"进程:{str(self.pro)},优先级:{str(self.priority)},到达时间:{str(self.arrive_time)},还需运行时间:{str(self.all_time)},已运行时间:{str(self.cpu_time)},开始阻塞时间:{str(self.start_block_time)},阻塞时间:{str(self.block_time)},状态:{self.state}")

         def output2(self):
             print(f'进程:{str(self.pro)},正在执行,到达时间:{str(self.arrive_time)},还需运行时间:{str(self.all_time)},已运行时间:{str(self.cpu_time)}')

         def toBlock(self):
             self.state = "Block"

         def toRun(self):
             self.state = "Run"

         def beFinish(self):
             self.state = "Finish"

         def beReady(self):
             self.state = "Ready"

         def running(self):
             self.all_time -= 1
             self.cpu_time += 1

         def toBlocking(self):
             if self.start_block_time > 0:
                 self.start_block_time -= 1

         def blocking(self):
             if self.block_time > 0:
                 self.block_time -= 1
                 self.priority += 1

     def init(num):
         list1 = []
         for i in range(num):
             list1.append(Pcb(str(i), random.randint(1, 10), random.randint(10, 15), random.randint(1, 10), 0, random.randint(5, 10), random.randint(1, 10), "Ready"))
         for i in range(len(list1) - 1):
             for j in range(i + 1, len(list1)):
                 if list1[i].arrive_time > list1[j].arrive_time:
                     list1[i], list1[j] = list1[j], list1[i]
         return list1

     def fcfs(list1):
         time = 0
         while True:
             print("time:", time)
             if time >= list1[0].arrive_time:
                 list1[0].running()
                 list1[0].output2()
                 if list1[0].all_time == 0:
                     print(f"进程:{list1[0].pro},执行完毕,周转时间:{str(time - list1[0].arrive_time + 1)}\n")
                     list1.remove(list1[0])
             time += 1
             if not list1:
                 break

     def sjf(list1):
         list2 = []  # 就绪队列
         time = 0
         while True:
             print("time:", time)
             if list1:
                 i = 0
                 while True:
                     if time == list1[i].arrive_time:
                         list2.append(list1[i])
                         list1.remove(list1[i])
                     i += 1
                     if i >= len(list1):
                         break
             if len(list2) >= 2:
                 for i in range(len(list2) - 1):
                     for j in range(i + 1, len(list2)):
                         if list2[i].all_time > list2[j].all_time:
                             list2[i], list2[j] = list2[j], list2[i]
             if list2:
                 pro = list2[0].pro
                 if pro != list2[0].pro:
                     print(f'发生抢占,进程:{list2[0].pro},开始执行')
                     pro = list2[0].pro
                 list2[0].running()
                 list2[0].output2()
                 if list2[0].all_time == 0:
                     print(f"进程:{list2[0].pro},执行完毕,周转时间:{str(time - list2[0].arrive_time + 1)}\n")
                     list2.remove(list2[0])
             time += 1
             if not list2 and not list1:
                 break

     def hrrn(list1):
         list2 = []  # 就绪队列
         list3 = []  # 阻塞队列
         time = 0
         while True:
             print("time:", time)
             if list1:
                 i = 0
                 while True:
                     if time == list1[i].arrive_time:
                         list2.append(list1[i])
                         list1.remove(list1[i])
                     i += 1
                     if i >= len(list1):
                         break
             if len(list2) >= 2:
                 for i in range(len(list2) - 1):
                     for j in range(i + 1, len(list2)):
                         if list2[i].priority < list2[j].priority:
                             list2[i], list2[j] = list2[j], list2[i]
             if list2:
                 pro = list2[0].pro
                 if pro != list2[0].pro:
                     print(f'发生抢占,进程:{list2[0].pro},开始执行')
                     pro = list2[0].pro
                 if list2[0].start_block_time > 0 or list2[0].block_time <= 0:
                     list2[0].toRun()
                     list2[0].running()
                     list2[0].toBlocking()
                 for i in range(1, len(list2)):
                     list2[i].priority += 1
                     list2[i].toBlocking()
             if list3:
                 for i in list3:
                     i.blocking()
             for i in list2:
                 i.output1()
             for i in list3:
                 i.output1()
             if list2:
                 i = 0
                 while True:
                     if list2[i].start_block_time == 0 and list2[i].block_time != 0:
                         print(f"进程:{list2[i].pro},开始阻塞,进入阻塞队列")
                         list2[i].toBlock()
                         list3.append(list2[i])
                         list2.remove(list2[i])
                     i += 1
                     if i >= len(list2):
                         break
             if list3:
                 i = 0
                 while True:
                     if list3[i].block_time == 0:
                         print(f"进程:{list3[i].pro},阻塞结束,进入就绪队列")
                         list3[i].beReady()
                         list2.append(list3[i])
                         list3.remove(list3[i])
                     i += 1
                     if i >= len(list3):
                         break
             if list2:
                 if list2[0].all_time <= 0:
                     list2[0].beFinish()
                     print(f"进程:{list2[0].pro},执行完毕,周转时间:{str(time - list2[0].arrive_time + 1)},状态:{list2[0].state}\n")
                     list2.remove(list2[0])
             time += 1
             if not (list1 or list2 or list3):
                 break

     if __name__ == "__main__":
         while True:
             n = input("请选择算法(1、先来先服务2、抢占式短作业优先3、动态最高优先数优先):")
             if n == "1":
                 list1 = init(4)
                 for i in list1:
                     i.output2()
                 fcfs(list1)
             elif n == "2":
                 list1 = init(4)
                 for i in list1:
                     i.output2()
                 sjf(list1)
             elif n == "3":
                 list1 = init(4)
                 for i in list1:
                     i.output1()
                 hrrn(list1)
             else:
                 print("输入错误,请重新输入!")

4. **运行程序**:
- 打开终端或命令行界面。
- 导航到项目的根目录。
- 运行以下命令：

     python 测试.py

- 按照提示选择需要模拟的进程调度算法（1、先来先服务；2、抢占式短作业优先；3、动态最高优先数优先）。

### 设计思路

1. **定义进程类 `Pcb`**:
- `Pcb` 类用于表示进程的基本属性，包括进程名、优先级、到达时间、总运行时间、已运行时间、开始阻塞时间、阻塞时间、当前状态等。
- 提供方法用于输出进程信息、改变进程状态、更新进程的运行时间和阻塞时间。

2. **初始化进程**:
- `init` 函数生成指定数量的进程，并按到达时间对进程进行排序。

3. **先来先服务调度算法 (FCFS)**:
- 按照进程的到达时间顺序依次执行。
- 记录每个进程的开始和结束时间，并计算其周转时间。

4. **抢占式短作业优先调度算法 (SJF)**:
- 每次选择剩余运行时间最短的进程执行。
- 如果新到达的进程剩余运行时间更短，则发生抢占。

5. **动态最高优先数优先调度算法 (HRRN)**:
- 每次选择优先级最高的进程执行。
- 动态调整进程的优先级，考虑等待时间和运行时间。
- 支持进程的阻塞和解除阻塞操作。

6. **主程序**:
- 提供用户交互界面，允许用户选择不同的调度算法。
- 根据用户选择调用相应的调度算法函数，并输出调度结果。

通过上述步骤和设计思路，可以有效地模拟不同进程调度算法的执行过程，并验证其正确性和性能。