详解操作系统四大常用的作业调度算法（FCFS丨SJF丨HRRN丨RR）

已于 2024-01-04 16:02:21 修改
阅读量2.4w 收藏 35
点赞数 22
分类专栏： 《 操作系统 》 文章标签： 算法 服务器 大数据 操作系统
于 2024-01-02 10:32:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68111267/article/details/135327860
版权

文章目录

先来先服务调度算法（FCFS）

先来先服务调度算法（First-Come, First-Served, FCFS）是一种基本的进程调度算法，其核心思想是按照作业到达时间的先后顺序进行调度。

FCFS调度算法的工作过程如下：

  1. 当一个作业到达时，将其放入就绪队列的末尾。
  2. 当前执行的作业执行完毕后，从就绪队列中选择队首的作业进行运行。
  3. 重复步骤2，直到所有作业都执行完毕。

FCFS调度算法的优点是实现简单，公平性较好。由于按照作业到达的先后顺序进行调度，所以所有作业都可以得到执行，不存在作业“饥饿”问题。

然而，FCFS调度算法也存在一些缺点。首先，如果有一个长作业在队首，那么后面的作业就必须等待很长时间才能得到执行，导致平均等待时间较长。而且，FCFS调度算法无法适应作业的不同执行时间，执行时间较长的作业会导致整个系统的响应时间变长。

总结来说，FCFS调度算法是一种简单易实现的调度算法，公平性较好。但在实际应用中，需要注意长作业的等待时间较长的问题。

样例1：

有三个作业按下表的时间提交给系统，请按照先来先服务的调度算法计算它们的平均周转时间T和平均带权周转时间W

作业号提交时刻作业长度
110：002小时
210：061小时
310:150.25小时

分析：按照先来先服务的原则，可以计算出各个作业在系统中的开始执行时刻、结束时刻、周转时间。为了一目了然，我们可以在给定表的基础上增加四个新的列：开始执行时刻、结束时刻、周转时间、带权周转时间

周转时间 = 作业结束时刻 - 作业提交时刻
带权周转时间 = 周转时间 / 作业长度

作业号提交时刻作业长度开始时刻结束时刻周转时间带权周转时间
110：002小时10：0012：0021
210：061小时12：0013：002.92.9
310：150.25小时13：0013：15312

三个作业的平均周转时间T和平均带权周转时间W为：

T =（2.00+2.90+3.00）/ 3 = 2.63（小时）
W =（1+2.9+12）/ 3 = 5.30（小时）

短作业优先调度算法（SJF）

短作业优先调度算法是一种常见的进程调度算法，其核心思想是优先执行执行时间较短的作业。短作业指的是估计执行时间短的作业，也可以理解为剩余执行时间短的作业。

短作业优先调度算法的工作过程如下：

  1. 首先，按照作业的执行时间对待执行的作业队列进行排序，即将估计执行时间较短的作业排在前面。
  2. 然后，选择执行时间最短的作业来运行，直到该作业执行完毕或者被阻塞。
  3. 当作业执行完毕或者被阻塞时，从待执行作业队列中选择下一个执行时间最短的作业来运行。
  4. 重复步骤2和步骤3，直到所有作业都执行完毕。

短作业优先调度算法的优点是可以最大程度地减少平均等待时间，使得作业能够快速执行完毕。然而，该算法可能会导致长作业等待时间过长，造成长作业的“饥饿”现象。

总结来说，短作业优先调度算法是一种简单高效的调度算法，适用于执行时间短的作业，并能够减少平均等待时间。但在实际应用中需要注意长作业的“饥饿”问题。

样例2：

还是上面的例子，请按短作业优先算法计算它们的平均周转时间和平均带权周转时间

作业号提交时刻作业长度
110：002小时
210：061小时
310：150.25小时

分析：为了运算方便，在上面作业表的基础上增加五个新的列：调度次序、开始执行时刻、结束时刻、周转时间，以及带权周转时间，从而得到下面的表：

作业号提交时刻作业长度调度次序开始时刻结束时刻周转时间带权周转时间
110：002小时110：0012：0021
210：061小时312：1513：153.13.1
310：150.25小时212：0012：1528

三个作业的平均周转时间T和平均带权周转时间W为：

T =（2.00+3.10+2.00）/ 3 = 2.37（小时）
W =（1+2.9+12）/ 3 = 4.03（小时）

高响应比优先调度算法（HRRN）

高响应比优先调度算法（High Response Ratio Next, HRRN）是一种动态优先级的进程调度算法，其核心思想是根据作业的响应比来确定执行顺序。

HRRN调度算法的工作过程如下：

  1. 当一个作业到达时，计算其响应比。响应比定义为作业等待时间加上作业执行时间除以作业执行时间，即 (等待时间 + 作业长度) / 作业长度。
  2. 将计算得到的响应比最高的作业放入就绪队列。
  3. 当前执行的作业执行完毕后，从就绪队列中选择响应比最高的作业进行运行。
  4. 重复步骤2和步骤3，直到所有作业都执行完毕。

HRRN调度算法的优点是能够根据作业的等待时间和执行时间动态调整优先级，使得等待时间较长的作业能够优先得到执行，提高系统的响应速度。

然而，HRRN调度算法也存在一些缺点。首先，计算响应比需要动态获取作业的等待时间和执行时间，增加了系统的开销。此外，如果作业的执行时间很短，那么响应比会很高，导致其他作业长时间等待，可能会出现“长作业优先”问题。

总结来说，HRRN调度算法是一种具有动态优先级的调度算法，能够提高系统的响应速度。但需要注意计算响应比的开销以及长作业优先问题。

样例3：

表中有4个作业提交给系统，按响应比高者优先算法调度，计算它们的平均周转时间和平均带权周转时间

作业号提交时刻运行长度
18：002小时
28：300.5小时
39：000.1小时
49：300.2小时

分析：为了计算方便，同样在表中增加五个新列：调度次序、开始执行时刻、结束时刻、周转时间，以及带权周转时间

先画出一个表格，后五列是空的，等待我们填入数据：

作业号提交时刻运行长度调度次序开始时刻结束时刻周转时间带权周转时间
18：002小时
28：300.5小时
39：000.1小时
49：300.2小时

作业1做完后，其它三个作业的响应比为：
R2p = 1 + 已等待时间/作业长度 = 1 + 1.5/0.5 = 4
R3p = 1 + 1.0/0.1 = 11
R4p = 1 + 0.5/0.2 = 3.5
故作业3的响应比最大，作业1完成后要运行作业3。

作业3运行结束时，时间为10：06，这时候再看作业2、4的响应比哪个高：
R2p = 1 + 已等待时间/作业长度 =1 + 1.6/0.5 = 4.2
R4p = 1 + 0.6/0.2 = 4
R2p > R4p 所以先调度作业2到内存中，作业2运行完毕，结束时间为：10：36，最后调入作业4到内存。即作业调度的次序为：作业1、作业3、 作业2、 作业4

作业号提交时刻运行长度调度次序开始时刻结束时刻周转时间带权周转时间
18：002小时18：0010：0021
28：300.5小时310：0610：362.14.2
39：000.1小时210：0010：061.111
49：300.2小时410：3610：481.36.5

根据上面的表，可计算出4个作业的平均周转时间T和平均带权周转时间W为：

T =（2+2.1+1.1+1.3）/ 4 = 1.625（小时）
W =（1+4.2+11+6.5）/ 4 = 5.675（小时）

时间片轮转调度算法（RR）

时间片轮转调度算法（Round Robin Scheduling）是一种基于时间片的进程调度算法，旨在公平地分配CPU时间给各个就绪进程。

时间片轮转调度算法的工作过程如下：

  1. 将所有就绪进程按照到达时间的顺序放入就绪队列。
  2. 设定一个固定的时间片大小，通常为几十毫秒。
  3. 从就绪队列中选择一个进程，分配给它一个时间片的CPU时间。
  4. 若该进程在时间片结束前完成任务，则该进程被移出就绪队列，否则将其放到队列的末尾等待下一次调度。
  5. 重复步骤3和步骤4，直到所有进程执行完毕。

时间片轮转调度算法的优点是能够公平地分配CPU时间给每个就绪进程，避免某个进程独占CPU资源，从而提高系统的可响应性和吞吐量。

然而，时间片轮转调度算法也存在一些缺点。首先，如果时间片太短，频繁进行上下文切换会带来较大的开销。另外，如果某些进程的执行时间较长，会导致其他进程长时间等待，可能会出现“长作业效应”问题。

总结来说，时间片轮转调度算法是一种能够公平分配CPU时间的调度算法，适用于多道程序环境。但需要注意时间片大小的设置以及长作业效应问题。

样例4：

5个进程P1、P2、P3、P4、P5几乎同时到达，预期运行时间分别为10、6、2、4、8个时间单位。请按时间片轮转调度算法计算任务的平均周转时间（假定时间片大小为2个时间单位）。

分析：

按顺序运行5个进程

进程号P1P2P3P4P5备注
剩余运行时间106248
第一趟246810P3运行完
剩余运行时间84026
第二趟12141618P4运行完
剩余运行时间62004
第三趟2022024P2运行完
剩余运行时间40002
第四趟2628P5运行完
剩余运行时间20000
第四趟30P1运行完

时间片轮转调度顺序：
顺序

平均值
周转时间101618223019.2
带权周转时间12.6795.53.754.384
Want595
关注
  • 22
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
订阅专栏
Java模拟操作系统实验之四种进程调度算法实现（FCFS,SJF,RR,HRN）
01-01
Java平台下的四种进程调度算法的模拟实现，代码精简，内有详细注释，看不懂随时call我
Scheduling_algo：操作系统调度算法，FCFS和SJF
02-04
操作系统调度算法 先来先服务（FCFS）和最短作业优先（SJF）调度 此代码是非抢占式的 这些算法是非抢占式或抢占式的。 非抢占式算法的设计使进程一旦进入运行状态，就无法抢占它，直到它完成其分配的时间为止，而抢占式调度基于优先级，调度程序可以在高优先级时随时抢占低优先级的运行进程。进程进入就绪状态。 先来先服务（FCFS） 作业以先到先得的原则执行。 它是一种非抢先式，抢先式调度算法。 易于理解和实施。 它的实现基于FIFO队列。 由于平均等待时间较长，因此性能较差。 最短作业优先（SJF） 最短作业优先（SJF）或紧随其后的最短作业是一种调度策略，它选择执行时间最短的等待进程来执
课程设计大作业C++模拟操作系统进程调度FCFS和SJF算法实现源码.zip
06-17
课程设计大作业C++模拟操作系统进程调度FCFS和SJF算法实现源码 问题描述 设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T1, … ,Tn时刻到达系统，它们需要的服务时间分别为S1, … ,Sn。分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度，计算每个进程的完成时间，周转时间、带权周转时间和等待时间，并且统计n个进程的平均周转时间、平均带权周转时间和平均等待时间。最后，对两个算法做出比较评价。 要求采用先来先服务FCFS和短作业优先SJF分别调度进程运行，计算每个进程的周转时间，带权周转时间和等待时间，并且计算所有进程的平均周转时间，带权平均周转时间和平均等待时间。
操作系统作业调度算法FCFS(物联网，仅供参考).rar
05-25
先来先服务的调度算法：最简单的调度算法，既可以用于作业调度 ，也可以用于程序调度，当作业调度中采用该算法时，系统将按照作业到达的先后次序来进行调度，优先从后备队列中，选择一个或多个位于队列头部的作业，把他们调入内存，分配所需资源、创建进程，然后放入“就绪队列”,直到该进程运行到完成或发生某事件堵塞后，进程调度程序才将处理机分配给其他进程。
操作系统：进程调度算法(FCFS、SJF、HRRN、RR、HPF、MFQ)
最新发布
qq_64680177的博客
12-04 935
​时间片轮转调度算法（RR）：这的基本思想是将CPU的时间分割成若干个小的时间段，称为时间片，将这个时间片分给每一个进程，在这段时间内这个进程会在CPU中执行在这个法 中有两种情况程序会让出CPU：当时间片用完了之后这个进程的程序还没有执行完毕，则会让出CPU重新进入就绪队列等待被选中，CPU会继续从就绪队列中选择下一个进程执行。 当时间片还没用完，程序发生阻塞或者执行完毕，也会立即让出CPU。在这个算法中时间片的大小很重要，要是太小则会导致CPU上下文切换频繁，浪费资
操作系统调度算法--高响应比优先调度算法解析
qq_52959680的博客
12-07 2万+
高响应比优先调度算法（Highest Response Radio Next，HRRN）是一种对CPU中央控制器响应比的分配的算法。HRRN是介于FCFS（先来先服务算法）与SJF（短作业优先算法）之间的折中算法。FCFS算法所考虑的只是作业等待时间，而忽视了作业的运行时间（类似我们在生活中排队买东西）。而SJF算法正好与之相反，只考虑作业的运行时间，而忽视了作业的等待时间。 而高响应比优先算法，则是考虑了作业的等待时间，又考虑了作业运行时间的调度算法，因此照顾了短作业，又不致使长作业等待时间过长，从而改
最高响应比优先算法（HRRF）及例题详解
m0_56578216的博客
06-02 4万+
最高响应比优先算法（HRRF）：最高响应比优先算法是介于先来先服务算法（FCFS）和最短作业优先算法（SJF）之间的一种算法，它既考虑了作业的等待时间，又考虑了作业的处理时间。调度规则：响应比最高的作业先运行。优点：HRRF对于作业的时间分配比较均匀，既照顾了短作业，又不至于使长作业等待时间过长。缺点：HRRF每次计算响应比都会花费一定的时间，即时间开销。其性能比SJF算法略差。响应比的计算： 响应比=作业周转时间/作业处理时间 =（作业等待时间+作业处理时间）/作业处
高响应比优先调度算法（HRRN）例题详解
热门推荐
全 洛的博客
03-25 6万+
高响应比优先调度算法 （HRRN） 高响应比优先调度算法（Highest Response Ratio Next）是一种对CPU中央控制器响应比的分配的一种算法。HRRN是介于FCFS（先来先服务算法）与SJF（短作业优先算法）之间的折中算法，既考虑作业等待时间又考虑作业运行时间，既照顾短作业又不使长作业等待时间过长，改进了调度性能。 响应比=作业周转时间/作业处理时间=（作业处理时间+作业等待时...
HRRN调度算法（操作系统）响应比优先
m0_47642376的博客
08-21 2万+
HRRN（高响应比优先算法） 算法思想： 要综合考虑作业/进程的等待时间和要求服务时间 算法规则： 在每次调度时先计算各个作业/进程的响应比，选择响应比最高 的作业/进程为其服务 响应比： 响应比=（等待时间+要求服务时间）/要求服务时间 用于调度： 即可以用于作业调度，也可以用于进程调度 是否可以抢占： 非抢占式的算法。因此只有当前运行的作业/进程主动放弃处理机时，才需要调度，才需要计算响应比。 例题 例题：各进程到达就绪队列的时间、需要的运行时间如下所示，使用非抢占式的短作业优先调度算法，计算各进程
【操作系统】进程调度算法
blblccc
03-24 1851
【操作系统】进程调度算法
操作系统调度算法FCFS、SJF、RR、多级反馈算法
05-06
CPU的几种调度算法的C++实现。包括FCFS、SJF、RR、多级反馈的几种算法。
FCFS.zip_FCFS S_fcfs _sjf_作业调度算法
09-19
作业调度三种算法FCFS，SJF，HRN
操作系统实验 FCFS和短作业优先SJF调度算法模拟.pdf
03-29
操作系统实验 FCFS和短作业优先SJF调度算法模拟.pdf操作系统实验 FCFS和短作业优先SJF调度算法模拟.pdf操作系统实验 FCFS和短作业优先SJF调度算法模拟.pdf操作系统实验 FCFS和短作业优先SJF调度算法模拟.pdf操作系统...
C++实现SRT、FCFS、SJF、RR、HRRN和银行家算法.zip
12-15
自己学习C++的时候写的项目： C++实现SRT、FCFS、SJF、RR、HRRN和银行家算法
基于python模拟FCFS_SJF_RR_SRTF调度算法源码(课程作业).zip
08-21
【资源说明】 基于python模拟FCFS_SJF_RR_SRTF调度算法源码(课程作业).zip ...基于python模拟FCFS_SJF_RR_SRTF调度算法源码(课程作业).zip基于python模拟FCFS_SJF_RR_SRTF调度算法源码(课程作业).zip
【操作系统】调度算法（FCFS、SJF、HRRN、RR、优先级调度、多级反馈队列）
阿琪
05-07 2万+
简单介绍几种调度算法：先来先服务调度算法（FCFS）、短作业(进程)优先调度算法（SJ(P)F）、 优先级调度算法、高响应比优先调度算法、时间片轮转法（RR）、多级反馈队列调度算法。
FCFS、SJF、HRRN调度算法以及时间片轮转、优先级调度算法、多级反馈队列算法总结
qq_45044588的博客
10-19 4660
先来先服务（FCFS） 算法思想 主要从“公平“角度考虑 算法规则 按照作业/进程到达的先后顺序进行服务 用于作业/进程调度？ 用于作业调度时，考虑哪个作业先到达后备队列； 用于进程调度时，考虑哪个进程先到达就绪队列。 是否可抢占？ 非抢占式的算法 优缺点 优点：公平、算法实现简单 缺点：排在长作业（进程）后面的短作业需要等待很长时间，带权周转时间很大，对短作业来说用户体验不好。即FCFS算法对长作业有利，对短作业不利。 是否会导致饥饿？ 不会 例题 短作业优先（SJF） 算法思想 追求最少的
【调度】操作系统中调度算法（FCFS、RR、SPN（SJF）、SRT、HRRN）
bandaoyu的note
07-03 5191
决策模式 决策模式说明选择函数在执行的瞬间的处理方式，通常分为以下两类： 非抢占：一旦进入运行状态，就不会终止直到运行结束。 抢占：当前正在运行的进程可以被打断，并转移到就绪态。 一个调度算法是否能抢占，对进程的顺序有着极大的影响。 先来先服务FCFS 先来先服务是最简单的策略，也成为先进先出FIFO。首先它是一个非抢占的。如字面的意思，它根据进程到达时间决定先运行哪一个进程。 这里给出一个实际的例子。以表格的形式表现出在FIFO策略下各进程的情况。 简单说就是依次执行完成，从...
操作系统【作业调度算法 调度图 例题（SPF、HPF、HRRN）】
upward
04-29 9216
操作系统【作业调度算法 调度图 例题（SPF、HPF、HRRN）】
操作系统多进程调度 FCFS，SJF，RR算法（Java实现）
06-12
操作系统中的进程调度算法有很多，其中比较常见的有FCFS（先来先服务）、SJF（短作业优先）和RR（时间片轮转）等。下面分别介绍这三种调度算法的Java实现。 1. FCFS算法实现 FCFS算法即先来先服务，按照进程到达的顺序进行调度。 ``` import java.util.LinkedList; import java.util.Queue; public class FCFS { public static void main(String[] args) { Queue<Process> queue = new LinkedList<>(); // 创建进程并加入队列 queue.offer(new Process(1, 0)); queue.offer(new Process(2, 2)); queue.offer(new Process(3, 3)); queue.offer(new Process(4, 5)); int currentTime = 0; // 当前时间 int totalWaitTime = 0; // 总等待时间 while (!queue.isEmpty()) { Process process = queue.poll(); // 进程等待时间 int waitTime = currentTime - process.getArrivalTime(); totalWaitTime += waitTime; // 更新当前时间 currentTime += process.getBurstTime(); System.out.printf("Process %d:\n", process.getPid()); System.out.printf("Arrival Time: %d\n", process.getArrivalTime()); System.out.printf("Burst Time: %d\n", process.getBurstTime()); System.out.printf("Wait Time: %d\n", waitTime); System.out.printf("Turnaround Time: %d\n", waitTime + process.getBurstTime()); System.out.println(); } // 平均等待时间 double avgWaitTime = (double) totalWaitTime / 4; System.out.printf("Average Wait Time: %.2f\n", avgWaitTime); } static class Process { private int pid; // 进程ID private int arrivalTime; // 到达时间 private int burstTime; // 资源占用时间 public Process(int pid, int arrivalTime) { this.pid = pid; this.arrivalTime = arrivalTime; this.burstTime = (int) (Math.random() * 10) + 1; // 随机生成资源占用时间 } public int getPid() { return pid; } public int getArrivalTime() { return arrivalTime; } public int getBurstTime() { return burstTime; } } } ``` 输出结果为： ``` Process 1: Arrival Time: 0 Burst Time: 6 Wait Time: 0 Turnaround Time: 6 Process 2: Arrival Time: 2 Burst Time: 2 Wait Time: 4 Turnaround Time: 6 Process 3: Arrival Time: 3 Burst Time: 9 Wait Time: 7 Turnaround Time: 16 Process 4: Arrival Time: 5 Burst Time: 7 Wait Time: 11 Turnaround Time: 18 Average Wait Time: 5.50 ``` 2. SJF算法实现 SJF算法即短作业优先，按照进程执行的时间进行调度。 ``` import java.util.*; public class SJF { public static void main(String[] args) { List<Process> list = new ArrayList<>(); // 创建进程并加入列表 list.add(new Process(1, 0, 6)); list.add(new Process(2, 2, 2)); list.add(new Process(3, 3, 9)); list.add(new Process(4, 5, 7)); int currentTime = 0; // 当前时间 int totalWaitTime = 0; // 总等待时间 // 按照执行时间排序 Collections.sort(list, Comparator.comparingInt(Process::getBurstTime)); for (Process process : list) { // 进程等待时间 int waitTime = currentTime - process.getArrivalTime(); totalWaitTime += waitTime; // 更新当前时间 currentTime += process.getBurstTime(); System.out.printf("Process %d:\n", process.getPid()); System.out.printf("Arrival Time: %d\n", process.getArrivalTime()); System.out.printf("Burst Time: %d\n", process.getBurstTime()); System.out.printf("Wait Time: %d\n", waitTime); System.out.printf("Turnaround Time: %d\n", waitTime + process.getBurstTime()); System.out.println(); } // 平均等待时间 double avgWaitTime = (double) totalWaitTime / 4; System.out.printf("Average Wait Time: %.2f\n", avgWaitTime); } static class Process { private int pid; // 进程ID private int arrivalTime; // 到达时间 private int burstTime; // 资源占用时间 public Process(int pid, int arrivalTime, int burstTime) { this.pid = pid; this.arrivalTime = arrivalTime; this.burstTime = burstTime; } public int getPid() { return pid; } public int getArrivalTime() { return arrivalTime; } public int getBurstTime() { return burstTime; } } } ``` 输出结果为： ``` Process 2: Arrival Time: 2 Burst Time: 2 Wait Time: 0 Turnaround Time: 2 Process 1: Arrival Time: 0 Burst Time: 6 Wait Time: 2 Turnaround Time: 8 Process 4: Arrival Time: 5 Burst Time: 7 Wait Time: 3 Turnaround Time: 10 Process 3: Arrival Time: 3 Burst Time: 9 Wait Time: 7 Turnaround Time: 16 Average Wait Time: 3.00 ``` 3. RR算法实现 RR算法即时间片轮转，每个进程被分配一个时间片，当时间片用完后，系统会进行调度。 ``` import java.util.LinkedList; import java.util.Queue; public class RR { public static void main(String[] args) { Queue<Process> queue = new LinkedList<>(); // 创建进程并加入队列 queue.offer(new Process(1, 0)); queue.offer(new Process(2, 2)); queue.offer(new Process(3, 3)); queue.offer(new Process(4, 5)); int currentTime = 0; // 当前时间 int totalWaitTime = 0; // 总等待时间 int timeSlice = 2; // 时间片大小 while (!queue.isEmpty()) { Process process = queue.poll(); // 进程等待时间 int waitTime = currentTime - process.getArrivalTime(); totalWaitTime += waitTime; // 更新当前时间 if (process.getBurstTime() > timeSlice) { // 时间片用完后放回队列 process.setBurstTime(process.getBurstTime() - timeSlice); currentTime += timeSlice; queue.offer(process); } else { // 进程执行完毕 currentTime += process.getBurstTime(); System.out.printf("Process %d:\n", process.getPid()); System.out.printf("Arrival Time: %d\n", process.getArrivalTime()); System.out.printf("Burst Time: %d\n", process.getBurstTime()); System.out.printf("Wait Time: %d\n", waitTime); System.out.printf("Turnaround Time: %d\n", waitTime + process.getBurstTime()); System.out.println(); } } // 平均等待时间 double avgWaitTime = (double) totalWaitTime / 4; System.out.printf("Average Wait Time: %.2f\n", avgWaitTime); } static class Process { private int pid; // 进程ID private int arrivalTime; // 到达时间 private int burstTime; // 资源占用时间 public Process(int pid, int arrivalTime) { this.pid = pid; this.arrivalTime = arrivalTime; this.burstTime = (int) (Math.random() * 10) + 1; // 随机生成资源占用时间 } public int getPid() { return pid; } public int getArrivalTime() { return arrivalTime; } public int getBurstTime() { return burstTime; } public void setBurstTime(int burstTime) { this.burstTime = burstTime; } } } ``` 输出结果为： ``` Process 1: Arrival Time: 0 Burst Time: 1 Wait Time: 6 Turnaround Time: 7 Process 2: Arrival Time: 2 Burst Time: 1 Wait Time: 4 Turnaround Time: 5 Process 3: Arrival Time: 3 Burst Time: 5 Wait Time: 4 Turnaround Time: 9 Process 4: Arrival Time: 5 Burst Time: 6 Wait Time: 5 Turnaround Time: 11 Average Wait Time: 4.75 ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Want595

感谢小伙伴的支持！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值