优先级的时间片轮转算法（操作系统实验）

╰半橙微兮° 2022-07-14 00:55 240阅读 0赞

实验题目：
基于优先数的时间片轮转调度算法调度处理器

一、实验目的
在采用多道程序设计的系统中，同时处于就绪态的进程往往有多个，当就绪态的进程数大于处理器的个数时，就需按照某种策略进行分配处理器。本次设计模拟在单处理器情况下采用基于优先数的时间片轮转调度算法进行处理器调度，加深了解处理器调度工作过程。
二、实验内容及要求
1、设计一个程序实现基于优先数的时间片轮转调度算法调度处理器。
2、假定系统有5个进程，每个进程用一个进程控制块PCB开代表，进程控制块的结构如下图1.2所示：

  1. 进程名
  2.   指针
  3.   到达时间
  4.   要求运行时间
  5.   已运行时间
  6.   优先数

进程状态
图1
其中：
进程名：作为进程的标识。
指针：进程按顺序排成循环链表，用指针指出下一个进程的进程控制块首地址，最后一个进程中的指针指出第一个进程的进程控制块首地址。
要求运行时间：假设进程需要运行的单位时间数。
已运行时间：假设进程已经运行的单位时间数，初值为0。
状态：可假设有两种状态，就绪状态和结束状态。进程的初始状态都为就绪状态。
3、每次运行所设计的处理器调度程序调度进程之前，为每个进程任意确定它的要求运行时间。
4、此程序是模拟处理器调度，因此，被选中的进程并不实际启动运行，而是执行
已运行时间+1
来模拟进程的一次运行，表示进程已经运行过一个单位时间。
.5、在所设计的程序中应有显示或打印语句，能显示或打印每次被选中的进程名以及运行一次后进程队列的变化。
6、为进程任意确定要求运行时间，运行所设计的处理器调度程序，显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。
7、设有一个就绪队列，就绪进程按优先数（优先数范围0－100）由小到大排列（优先数越小，级别越高）。当某一进程运行完一个时间片后，其优先级应下调（如优先数加2或3）。

三丶 主要解决办法
3.1 判断进程是否在就绪队列中

  1. wait_run_list = new ArrayList<>();
  3.             // 此处将所有进程中等待执行的序列的进程选出 由current_time 判断进程是否在等待序列中
  4.             for (ProgressTest pt : list) {
  5.                 // 是否在就绪队列 是否执行完毕
  6.                 if (current_time >= pt.arrive_time
  7.                         && pt.do_service_time != pt.service_time) {
  8.                     wait_run_list.add(pt);
  9.                 }
  10.             }

3.2 List list 排序

  1. Collections.sort(wait_run_list, new Comparator<ProgressTest>() {
  2.                 public int compare(ProgressTest arg0, ProgressTest arg1) {
  3.                     return arg0.priority < arg1.priority ? -1 : 1;
  4.                 }
  5.             });

四丶完整代码

  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.Comparator;
  4. import java.util.Iterator;
  5. import java.util.List;
  7. /* * 编码格式utf-8 * 实现内容： 优先级的时间片轮转算法 *priority (优先级) 数字越小 优先级越高 * * @author songjiang 2016.11.21 * @jdk 1.7 * @version 1.0 */
  9. public class ProgressTest { 
  10.     private int arrive_time;     //到达时间
  11.     private int service_time;    //服务时间
  12.     private int do_service_time; // 已运行时间
  13.     private int priority;
  14.     private boolean state;       //运行状态 false为完成 true为就绪
  15.     private char name;
  17.     public static int current_time;
  18.     public static int total_time;
  20.     static List<ProgressTest> list = new ArrayList<>();
  21.     static List<ProgressTest> wait_run_list = null;
  23.     public static void main(String[] args) throws InterruptedException {
  24.         ProgressTest A = new ProgressTest(65, 0, 6, (int) (Math.random() * 60));
  25.         ProgressTest B = new ProgressTest(66, 2, 10, (int) (Math.random() * 60));
  26.         ProgressTest C = new ProgressTest(67, 3, 5, (int) (Math.random() * 60));
  27.         ProgressTest D = new ProgressTest(68, 6, 1, (int) (Math.random() * 60));
  28.         ProgressTest E = new ProgressTest(69, 8, 2, (int) (Math.random() * 60));
  29.         ProgressTest F = new ProgressTest(70, 12, 5, (int) (Math.random() * 60));
  31.         list.add(A);
  32.         list.add(B);
  33.         list.add(C);
  34.         list.add(D);
  35.         list.add(E);
  36.         list.add(F);
  38.         total_time = getTotalTime(list);
  40.         doRRbyPriority(list);
  42.     }
  44.     private static void doRRbyPriority(List<ProgressTest> list)
  45.             throws InterruptedException {
  47.         while (current_time <= total_time) {
  48.             wait_run_list = new ArrayList<>();
  50.             // 此处将所有进程中等待执行的序列的进程选出 由current_time 判断进程是否在等待序列中
  51.             for (ProgressTest pt : list) {
  52.                 // 是否在就绪队列 是否执行完毕
  53.                 if (current_time >= pt.arrive_time
  54.                         && pt.do_service_time != pt.service_time) {
  55.                     wait_run_list.add(pt);
  56.                 }
  57.             }
  59.             Collections.sort(wait_run_list, new Comparator<ProgressTest>() {
  60.                 public int compare(ProgressTest arg0, ProgressTest arg1) {
  61.                     return arg0.priority < arg1.priority ? -1 : 1;
  62.                 }
  63.             });
  65.             System.out.println("就绪队列wait_run_list：" + wait_run_list.toString());
  67.             System.out.println(current_time + " " + total_time + " "
  68.                     + current_time);
  69.             if (wait_run_list.size() > 0) {
  70.                 ProgressTest pt = wait_run_list.get(0);
  71.                 if (pt.checkProgress())
  72.                 {
  73.                     pt.doOnceRun();
  74.                     current_time++; // 一次执行一个时间片
  75.                     System.out.println("当前运行" + pt.toString());
  76.                 }
  77.                 System.out.println();
  79.             } else {
  80.                 break;
  81.             }
  83.         }
  85.     }
  87.     public ProgressTest(int name, int arrive_time, int service_time,
  88.             int priority) {
  89.         this.arrive_time = arrive_time;
  90.         this.service_time = service_time;
  91.         this.priority = priority;
  92.         this.name = (char) name;
  93.         state = true; // 默认为就绪状态
  94.     }
  96.     // 获得总的运行时间
  97.     public static int getTotalTime(List<ProgressTest> list) {
  98.         int time = 0;
  99.         Iterator<ProgressTest> it = list.iterator();
  100.         while (it.hasNext()) {
  101.             ProgressTest pt = it.next();
  102.             time += pt.service_time;
  103.         }
  104.         return time;
  105.     }
  107.     // 一次运行时间 服务时间减一 上调优先数
  108.     public void doOnceRun() {
  109.         if (this.do_service_time < this.service_time) {
  110.             do_service_time++;
  111.         }
  113.         this.priority += 2;
  114.     }
  116.     public boolean checkProgress() {
  117.         if (this.do_service_time == this.service_time) {
  118.             state = false;
  119.             System.out.println(this.state + ",运行完毕");
  120.             return state;
  121.         } else {
  122.             return state;
  123.         }
  124.     }
  126.     @Override
  127.     public String toString() {
  128.         return this.name + " " + "已服务" + do_service_time + " 到达" + arrive_time
  129.                 + " 服务" + service_time + " 优先级" + priority;
  130.     }
  132. }

某次运行效果：
就绪队列wait_run_list：[A 已服务0 到达0 服务6 优先级48]
0 29 0
当前运行A 已服务1 到达0 服务6 优先级50

就绪队列wait_run_list：[A 已服务1 到达0 服务6 优先级50]
1 29 1
当前运行A 已服务2 到达0 服务6 优先级52

就绪队列wait_run_list：[B 已服务0 到达2 服务10 优先级26, A 已服务2 到达0 服务6 优先级52]
2 29 2
当前运行B 已服务1 到达2 服务10 优先级28

就绪队列wait_run_list：[C 已服务0 到达3 服务5 优先级1, B 已服务1 到达2 服务10 优先级28, A 已服务2 到达0 服务6 优先级52]
3 29 3
当前运行C 已服务1 到达3 服务5 优先级3

就绪队列wait_run_list：[C 已服务1 到达3 服务5 优先级3, B 已服务1 到达2 服务10 优先级28, A 已服务2 到达0 服务6 优先级52]
4 29 4
当前运行C 已服务2 到达3 服务5 优先级5

就绪队列wait_run_list：[C 已服务2 到达3 服务5 优先级5, B 已服务1 到达2 服务10 优先级28, A 已服务2 到达0 服务6 优先级52]
5 29 5
当前运行C 已服务3 到达3 服务5 优先级7

就绪队列wait_run_list：[C 已服务3 到达3 服务5 优先级7, D 已服务0 到达6 服务1 优先级18, B 已服务1 到达2 服务10 优先级28, A 已服务2 到达0 服务6 优先级52]
6 29 6
当前运行C 已服务4 到达3 服务5 优先级9

就绪队列wait_run_list：[C 已服务4 到达3 服务5 优先级9, D 已服务0 到达6 服务1 优先级18, B 已服务1 到达2 服务10 优先级28, A 已服务2 到达0 服务6 优先级52]
7 29 7
当前运行C 已服务5 到达3 服务5 优先级11

就绪队列wait_run_list：[D 已服务0 到达6 服务1 优先级18, E 已服务0 到达8 服务2 优先级20, B 已服务1 到达2 服务10 优先级28, A 已服务2 到达0 服务6 优先级52]
8 29 8
当前运行D 已服务1 到达6 服务1 优先级20

就绪队列wait_run_list：[E 已服务0 到达8 服务2 优先级20, B 已服务1 到达2 服务10 优先级28, A 已服务2 到达0 服务6 优先级52]
9 29 9
当前运行E 已服务1 到达8 服务2 优先级22

就绪队列wait_run_list：[E 已服务1 到达8 服务2 优先级22, B 已服务1 到达2 服务10 优先级28, A 已服务2 到达0 服务6 优先级52]
10 29 10
当前运行E 已服务2 到达8 服务2 优先级24

就绪队列wait_run_list：[B 已服务1 到达2 服务10 优先级28, A 已服务2 到达0 服务6 优先级52]
11 29 11
当前运行B 已服务2 到达2 服务10 优先级30

就绪队列wait_run_list：[F 已服务0 到达12 服务5 优先级28, B 已服务2 到达2 服务10 优先级30, A 已服务2 到达0 服务6 优先级52]
12 29 12
当前运行F 已服务1 到达12 服务5 优先级30

就绪队列wait_run_list：[B 已服务2 到达2 服务10 优先级30, F 已服务1 到达12 服务5 优先级30, A 已服务2 到达0 服务6 优先级52]
13 29 13
当前运行B 已服务3 到达2 服务10 优先级32

就绪队列wait_run_list：[F 已服务1 到达12 服务5 优先级30, B 已服务3 到达2 服务10 优先级32, A 已服务2 到达0 服务6 优先级52]
14 29 14
当前运行F 已服务2 到达12 服务5 优先级32

就绪队列wait_run_list：[B 已服务3 到达2 服务10 优先级32, F 已服务2 到达12 服务5 优先级32, A 已服务2 到达0 服务6 优先级52]
15 29 15
当前运行B 已服务4 到达2 服务10 优先级34

就绪队列wait_run_list：[F 已服务2 到达12 服务5 优先级32, B 已服务4 到达2 服务10 优先级34, A 已服务2 到达0 服务6 优先级52]
16 29 16
当前运行F 已服务3 到达12 服务5 优先级34

就绪队列wait_run_list：[B 已服务4 到达2 服务10 优先级34, F 已服务3 到达12 服务5 优先级34, A 已服务2 到达0 服务6 优先级52]
17 29 17
当前运行B 已服务5 到达2 服务10 优先级36

就绪队列wait_run_list：[F 已服务3 到达12 服务5 优先级34, B 已服务5 到达2 服务10 优先级36, A 已服务2 到达0 服务6 优先级52]
18 29 18
当前运行F 已服务4 到达12 服务5 优先级36

就绪队列wait_run_list：[B 已服务5 到达2 服务10 优先级36, F 已服务4 到达12 服务5 优先级36, A 已服务2 到达0 服务6 优先级52]
19 29 19
当前运行B 已服务6 到达2 服务10 优先级38

就绪队列wait_run_list：[F 已服务4 到达12 服务5 优先级36, B 已服务6 到达2 服务10 优先级38, A 已服务2 到达0 服务6 优先级52]
20 29 20
当前运行F 已服务5 到达12 服务5 优先级38

就绪队列wait_run_list：[B 已服务6 到达2 服务10 优先级38, A 已服务2 到达0 服务6 优先级52]
21 29 21
当前运行B 已服务7 到达2 服务10 优先级40

就绪队列wait_run_list：[B 已服务7 到达2 服务10 优先级40, A 已服务2 到达0 服务6 优先级52]
22 29 22
当前运行B 已服务8 到达2 服务10 优先级42

就绪队列wait_run_list：[B 已服务8 到达2 服务10 优先级42, A 已服务2 到达0 服务6 优先级52]
23 29 23
当前运行B 已服务9 到达2 服务10 优先级44

就绪队列wait_run_list：[B 已服务9 到达2 服务10 优先级44, A 已服务2 到达0 服务6 优先级52]
24 29 24
当前运行B 已服务10 到达2 服务10 优先级46

就绪队列wait_run_list：[A 已服务2 到达0 服务6 优先级52]
25 29 25
当前运行A 已服务3 到达0 服务6 优先级54

就绪队列wait_run_list：[A 已服务3 到达0 服务6 优先级54]
26 29 26
当前运行A 已服务4 到达0 服务6 优先级56

就绪队列wait_run_list：[A 已服务4 到达0 服务6 优先级56]
27 29 27
当前运行A 已服务5 到达0 服务6 优先级58

就绪队列wait_run_list：[A 已服务5 到达0 服务6 优先级58]
28 29 28
当前运行A 已服务6 到达0 服务6 优先级60

就绪队列wait_run_list：[]
29 29 29

发表评论

表情：
评论列表 （有 0 条评论，240人围观）

还没有评论，来说两句吧...

相关阅读

    相关 时间片轮转法（c语言）

    一、实验目的及要求 题目一：设计一个按照时间片轮转法实现处理机调度的程序 时间片轮转法实现处理机调度的程序设计提示如下： （1）假设系统有n个进程，每个进程用一个进

    小咪咪小咪咪/ 0 赞/ 117 阅读

    相关 操作系统 时间片轮转调度算法

    时间片轮转法（RR） 算法描述：用于分时系统中的进程调度。每次调度时，总是选择就绪队列的队首进程，让其在CPU上运行一个系统预先设置好的时间片。一个时间片内没有完成运行的进

    蔚落蔚落/ 0 赞/ 386 阅读