操作系统时间片轮转RR进程调度算法java版

操作系统课程设计时间片轮转算法j a v a实现 Document serial number【UU89WT-UU98YT-UU8CB-UUUT-UUT108】学校代码：10128课程设计题目：处理机管理模拟系统的设计与实现学生姓名：学院：信息工程学院系别：软件工程系专业：软件工程班级：指导教师：副教授讲师2013年1月8日内蒙古工业大学课程设计任务书（四）学院（系）：信息学院软件工程系课程名称：操作系统课程设计指导教师（签名）：专业班级：学生姓名：学号：摘要操作系统是计算机系统的关键组成部分，负责管理与配置内存、决定系统资源供需的优先次序、控制输入与输出设备、操作网络与管理文件系统等基本任务。

对于不同的系统和系统目标，通常采用不同的调度算法，如在批处理系统中，为照顾为数众多的短作业，采用短作业优先调度算法；在分时系统中，为保证系统具有合理的响应时间，采用时间片轮转法进行调度。

采用算法时，则要考虑多方面因素，以便达到最佳效果。

本次课程设计采用时间片轮转调度算法来实现模拟进程调度任务的执行过程。

用Java模拟进程调度过程，可以方便地将运行结果直观地表示出来。

Java语言独有的多线程操作，可以实现许多其他语言不能实现的功能，极大地方便了程序开发人员对程序的开发。

此外，利用JavaGUI编程，可以使系统提供的界面更加友好。

实验中，应用文件I/O操作、线程、AWT、Swing、内部类、接口、异常处理等技术，开发此系统。

关键字：时间片轮转； Java编程； GUI图形用户界面；文件操作；AbstractThe operating system is a key component of the computer system, responsible for the management and configuration memory, decided to system resources supply and demand priority, control input and output equipment, operation and management of network file system, and other basic different systems and system target, computers usually use different scheduling algorithm, such as in a Batch Processing System, in order to take care of a lot of short operation, using Short Job First algorithm;In systems with time sharing, to ensure the system has reasonable response time, need time slice Round Robin algorithm for scheduling. The algorithm, we should consider various factors, in order to achieve the best Course Design uses time slice Round Robin algorithm to simulate the process scheduling task execution process.With Java simulation process scheduling process, which can be conveniently will run results intuitively said addition, the use of JavaGUI programming, can make the system to provide theinterface more , application file I/O operation, threads, AWT, Swing, internal class, interface, abnormal processing technology, the development of this system.Keywords: time slice Round Robin; Java Programming; ;File Operation;目录第一章问题分析设计目的在多道程序或多任务系统中，系统同时处于就绪态的进程有若干个。

操作系统有哪些主要调度算法操作系统调度算法一、磁盘调度1.先来先服务fcfs：是按请求访问者的先后次序启动磁盘驱动器，而不考虑它们要访问的物理位置2.最短一般说来时间优先sstf：使距当前磁道最近的命令访问者启动磁盘驱动器，即是使查找时间最短的那个作业先继续执行，而不考量命令访问者到来的先后次序，这样就消除了先来先服务调度算法中磁臂移动过小的问题3.扫描算法scan或电梯调度算法：总是从磁臂当前位置开始，沿磁臂的移动方向去选择离当前磁臂最近的那个柱面的访问者。

如果沿磁臂的方向无请求访问时，就改变磁臂的移动方向。

在这种调度方法下磁臂的移动类似于电梯的调度，所以它也称为电梯调度算法。

4.循环读取算法cscan：循环读取调度算法就是在读取算法的基础上改良的。

磁臂改成单项移动，由外向里。

当前边线已经开始沿磁臂的移动方向回去挑选距当前磁臂最近的哪个柱面的访问者。

如果沿磁臂的方向并无命令出访时，再返回最外，出访柱面号最轻的作业命令。

操作系统调度算法二、进程调度算法1.先进先出算法fifo：按照进程步入准备就绪队列的先后次序去挑选。

即为每当步入进程调度，总是把准备就绪队列的队首进程资金投入运转。

2.时间片轮转算法rr：分时系统的一种调度算法。

轮转的基本思想是，将cpu的处理时间划分成一个个的时间片，就绪队列中的进程轮流运行一个时间片。

当时间片结束时，就强迫进程让出cpu，该进程进入就绪队列，等待下一次调度，同时，进程调度又去选择就绪队列中的一个进程，分配给它一个时间片，以投入运行。

3.最低优先级算法hpf：进程调度每次将处理机分配给具备最低优先级的准备就绪进程。

最低优先级算法可以与相同的cpu方式融合构成可以抢占市场式最低优先级算法和不容抢占市场式最低优先级算法。

4.多级队列反馈法：几种调度算法的结合形式多级队列方式。

操作系统调度算法三、常用的批处理作业调度算法1.先来先服务调度算法fcfs:就是按照各个作业进入系统的自然次序来调度作业。

操作系统时间片轮转算法与优先级调度算法操作系统作为计算机的核心，需要负责管理和分配系统资源的功能。

其中，调度算法是操作系统中非常重要的一个功能，它决定了如何分配CPU时间，因此直接影响系统的性能和响应速度。

本文将介绍两种操作系统中常用的调度算法：时间片轮转算法和优先级调度算法。

时间片轮转算法时间片轮转算法（Round Robin）是一种基本的调度算法，它是多道程序设计中常用的一种算法。

在内存中同时存放多个进程，并根据每个进程的优先级轮流分配 CPU 时间，以保证每个进程都能得到一定的CPU时间片，从而保证操作系统的公平性和系统的稳定性。

基本思想时间片轮转算法的基本思想是：将每个进程分配相同长度的CPU时间片，一旦时间片用完，立即将该进程挂起，并将 CPU 分配给下一个进程。

这样就可以保证每个进程都有相同的机会获得 CPU 时间，避免了某个进程长时间霸占CPU而导致其他进程无法运行的情况。

算法流程时间片轮转算法的具体实现过程如下：1.将所有待运行的进程加入到就绪队列中；2.从就绪队列中取出第一个进程，将其运行指定时间片长度的时间；3.如果该进程在运行时间片结束之前自己退出，那么直接将其从就绪队列中取出，释放资源；4.如果该进程在运行时间片结束之前没有自己退出，那么将其挂起放到队列的尾部，然后将 CPU 分配给下一个进程，重复2-4步骤，直到所有进程执行完毕。

算法优点时间片轮转算法的优点如下：1.公平：每个进程都能得到相同长度的时间片，避免了某个进程长时间霸占CPU的情况，从而保证了每个进程都会运行；2.适用：时间片轮转算法适用于多任务并发的环境下，可以有效地避免死锁和饥饿现象；3.高效：时间片轮转算法可以保证 CPU 的高效利用，能够最大限度地提高 CPU 的性能。

算法缺点时间片轮转算法的缺点如下：1.精度问题：时间片长度不能太长，否则会导致某些进程长时间等待CPU时间片；2.资源浪费：如果一个进程只需要很短的时间就可以完成任务，但由于时间片的限制而占用CPU的时间，这就是一种资源浪费。

几种操作系统调度算法操作系统调度算法是操作系统中用于确定进程执行的顺序和优先级的一种方法。

不同的调度算法有不同的优缺点，适用于不同的场景和需求。

下面将介绍几种常见的操作系统调度算法：1.先来先服务（FCFS）调度算法:先来先服务调度算法是最简单的调度算法之一、按照进程到达的顺序进行调度，首先到达的进程先执行，在CPU空闲时执行下一个进程。

这种算法实现简单，并且公平。

但是，由于没有考虑进程的执行时间，可能会导致长作业时间的进程占用CPU资源较长时间，从而影响其他进程的响应时间。

2.短作业优先（SJF）调度算法:短作业优先调度算法是根据进程的执行时间进行排序，并按照执行时间最短的进程优先执行。

这种算法可以减少平均等待时间，提高系统的吞吐量。

然而，对于长作业时间的进程来说，等待时间会相对较长。

3.优先级调度算法:优先级调度算法是根据每个进程的优先级来决定执行顺序的。

优先级可以由用户设置或者是根据进程的重要性、紧迫程度等因素自动确定。

具有较高优先级的进程将具有更高的执行优先级。

这种算法可以根据不同情况进行灵活调度，但是如果不恰当地设置优先级，可能会导致低优先级的进程长时间等待。

4.时间片轮转（RR）调度算法:时间片轮转调度算法将一个固定的时间片分配给每个进程，当一个进程的时间片用完时，将该进程挂起，调度下一个进程运行。

这种算法可以确保每个进程获得一定的CPU时间，提高系统的公平性和响应速度。

但是，对于长时间运行的进程来说，可能会引起频繁的上下文切换，导致额外的开销。

5.多级反馈队列（MFQ）调度算法:多级反馈队列调度算法将进程队列划分为多个优先级队列，每个队列有不同的时间片大小和优先级。

新到达的进程被插入到最高优先级队列，如果进程在时间片内没有完成，则被移到下一个较低优先级队列。

这种算法可以根据进程的执行表现自动调整优先级和时间片，更好地适应动态变化的环境。

以上是几种常见的操作系统调度算法，每种算法都有其优缺点和适用场景。

高响应比优先调度和时间片轮转rr进程调度算法-回复高响应比优先调度和时间片轮转RR进程调度算法引言：进程调度算法是操作系统中的重要组成部分，它决定了进程如何被分配和调度执行的顺序。

在操作系统中，有许多不同的进程调度算法可供选择。

本文将介绍两种常用的进程调度算法，分别是高响应比优先调度（HRN）和时间片轮转（Round-Robin，简称RR）算法。

本文将逐步回答关于这两种算法的原理、特点和应用场景等问题，以全面了解它们的工作原理和优势。

一、高响应比优先调度（HRN）算法1.1 原理介绍高响应比优先调度算法是一种动态优先级进程调度算法，它以进程的响应比为优先级判定标准。

响应比定义为等待时间加服务时间除以服务时间，代表了进程对系统资源的需求程度和等待时间的综合考虑。

对于一个长时间等待的进程，其响应比会不断增加，从而提高其优先级，以便及时得到服务。

1.2 特点和优势高响应比优先调度算法的特点和优势主要体现在以下几个方面：- 公平性：通过动态调整进程的优先级，保证了每个进程都有机会得到系统资源的分配。

- 短进程优先：长时间等待的进程会相应地提高其优先级，从而能够更早地得到服务，减少了等待时间。

- 高吞吐量：通过合理地考虑进程的等待时间和服务时间，提高了系统的吞吐量。

- 性能良好：与其他进程调度算法相比，高响应比优先调度算法的性能较好。

1.3 应用场景高响应比优先调度算法常常应用于实时操作系统和交互式计算机系统等对响应时间有较高要求的场景。

它能够合理地分配系统资源，提高用户对系统的响应感受，从而提高系统的可用性和用户满意度。

二、时间片轮转（RR）算法2.1 原理介绍时间片轮转（RR）算法是一种公平的进程调度算法，它将系统的CPU时间划分为相等的时间片，并按照轮转的方式分配给就绪队列中的进程。

每个进程在一个时间片内执行一定的时间后，被暂停并放回就绪队列尾部，下一个进程获得执行机会。

这样，所有进程都能够被公平地调度，避免了某个进程长时间占用CPU资源的情况。

时间片轮转调度算法java可视化模拟程序如何实现一个时间片轮转调度算法的java可视化模拟程序？时间片轮转调度算法是操作系统中常用的一种调度算法，它可以确保所有进程公平并且均衡地使用CPU资源。

在时间片轮转调度算法中，每个进程被分配一个固定的时间片，在这个时间片内执行，如果时间片用完，进程将被挂起，并将CPU资源分配给下一个进程。

为了更好地理解和学习时间片轮转调度算法，我们可以通过编写一个简单的java可视化模拟程序来模拟这个过程。

下面将一步一步回答如何实现这个模拟程序。

第一步：创建一个进程类我们需要创建一个Process类来表示每个进程。

这个类应该包含以下属性：- 进程ID（唯一标识符）- 进程名称- 进程到达时间- 进程需要的总执行时间- 进程已经执行的时间同时，这个类还应该包含一些方法来获取和修改这些属性的值。

第二步：创建一个调度类我们需要创建一个Scheduler类来模拟时间片轮转调度算法。

这个类应该包含以下属性：- 调度队列（用来存放进程的队列）- 时间片大小- 当前执行的进程同时，这个类还应该包含一些方法来模拟时间片轮转调度算法的执行过程，例如：- 将进程添加到调度队列- 根据时间片大小执行当前进程- 将当前进程挂起并将CPU资源分配给下一个进程第三步：编写可视化界面我们需要创建一个可视化界面来显示进程的执行和调度过程。

我们可以使用Java的图形界面库（如Swing或JavaFX）来实现这个界面。

界面应该包含以下组件：- 一个文本框用来输入进程的信息（进程ID，到达时间，执行时间等）- 一个按钮用来添加进程到调度队列- 一个文本框用来显示当前正在执行的进程信息- 一个文本框用来显示调度队列中的进程信息- 一个文本框用来显示每个进程的执行情况（已经执行的时间，还需要执行的时间等）- 一个按钮用来开始模拟时间片轮转调度算法的执行过程第四步：实现模拟程序的逻辑在可视化界面中，当用户点击“添加进程”按钮时，应该将进程添加到调度队列中。

高响应比优先调度和时间片轮转rr进程调度算法高响应比优先调度和时间片轮转（RR）进程调度算法引言：在操作系统中，进程调度是一项重要且复杂的任务。

为了提高系统的性能和响应速度，研究人员和工程师开发了许多不同的调度算法。

本文将重点介绍高响应比优先调度（high response ratio priority scheduling）和时间片轮转（round-robin, RR）进程调度算法。

这两种算法都在实际应用中得到了广泛的运用，下面我将对其原理进行详细阐述，并比较它们的优缺点。

一、高响应比优先调度算法高响应比优先调度算法是一种根据进程的等待时间和执行时间来确定优先级的策略。

该算法认为，等待时间越长的进程应该被优先执行，以提高整体系统的响应速度。

具体而言，高响应比=（等待时间+执行时间）/执行时间。

等待时间是指进程在就绪队列中等待调度的时间，而执行时间则是进程实际执行的时间。

高响应比优先调度算法的主要步骤如下：2. 计算响应比：对于每个进程，根据上述公式计算其响应比，并赋予一个优先级。

3. 选择优先级最高的进程：从就绪队列中选择响应比最高的进程，并将其调度到CPU中执行。

4. 更新进程状态：执行完一个时间片后，更新进程的等待时间和执行时间。

5. 重复步骤3和4，直到所有进程都执行完毕。

高响应比优先调度算法的优点在于能够充分利用CPU资源，提高系统的响应速度。

然而，该算法也存在一些缺点。

首先，计算每个进程的响应比需要消耗大量的计算资源。

其次，长时间等待的进程会获得较高的优先级，可能导致一些短进程长时间得不到执行。

因此，在实际应用中需要权衡考虑。

二、时间片轮转调度算法时间片轮转调度算法是一种公平的调度策略，它将CPU的执行时间划分为固定长度的时间片，并将每个进程分配一个时间片来执行。

当一个时间片耗尽后，进程将被重新放入就绪队列中，等待下一次调度。

时间片轮转调度算法的主要步骤如下：2. 选择当前时间片内的进程：从就绪队列中选择一个进程，并将其调度到CPU中执行。

常用的进程调度算法
常用的进程调度算法有：
1. 先来先服务（FCFS）：按照进程到达的顺序进行调度，先
到达的进程先执行。

2. 短作业优先（SJF）：按照进程执行时间的长短进行调度，
先执行执行时间短的进程。

3. 优先级调度：每个进程都有一个优先级，按照优先级进行调度，优先级高的先执行。

4. 轮转调度（RR）：按照进程到达的顺序进行调度，每个进
程执行一个时间片（时间片大小可以设定），然后进行切换。

5. 多级反馈队列调度：将进程分为多个队列，每个队列具有不同的优先级，每个队列都按照先来先服务的原则进行调度，当一个进程运行时间超过一个时间片时，将其放入下一个优先级更低的队列中。

6. 最短剩余时间优先（SRTF）：在短作业优先算法的基础上，每次发生进程切换时，都会比较剩余运行时间，优先执行剩余时间最短的进程。

7. 最高响应比优先（HRRN）：按照响应比（等待时间+执行
时间/执行时间）进行调度，响应比越高，优先级越高。

8. 最早截止时间优先（EDF）：按照进程的截止时间进行调度，优先执行截止时间最早的进程。

这些算法适用于不同的场景和需求，可以根据具体的情况选择合适的调度算法来提高系统性能。

时间片轮转RR进程调度算法时间片轮转（Round-Robin，简称RR）是一种常见的进程调度算法，它被广泛应用于操作系统中。

在RR算法中，每个进程被分配一个时间片，当时间片用完后，操作系统会将CPU的控制权交给下一个就绪队列中的进程。

这种算法的主要目标是公平地分配CPU时间，并且保证所有进程能够得到一定的执行时间，避免一些进程长时间占用CPU。

1.创建就绪队列：当进程处于就绪状态时，将其加入就绪队列中，按照先来先服务原则进行排队。

2.分配时间片：给每个进程分配一个固定长度的时间片，通常为10-100毫秒，具体取决于系统的要求。

3.执行进程：选择就绪队列中的第一个进程执行，并将其从队列中取出。

4.时间片到期：当进程执行的时间超过了分配给它的时间片长度时，需要进行下一步操作。

5.时间片用完：将当前正在执行的进程重新加入到就绪队列中，并且将下一个进程从队列中取出继续执行。

6.进程完成：当进程执行完毕后，将其标记为已完成，并从就绪队列中移除。

7.循环执行：循环执行以上步骤，直到所有进程都完成执行。

然而，时间片轮转算法也存在一些缺点：1.时间片长度选择：时间片过短会导致频繁的上下文切换，增加了系统开销；时间片过长则可能导致一些进程长时间占用CPU。

2.需要等待时间：如果一些进程的执行时间过长，其他进程可能需要等待较长时间才能获得CPU的控制权，影响了系统的响应速度。

3.无法适应突发性任务：对于一些突发性任务，时间片轮转算法可能无法满足其紧急性，因为它只能按照排队顺序执行进程。

为了解决这些问题，可以采取一些改进措施，例如：1.动态调整时间片长度：根据系统的运行情况动态调整时间片的长度，避免了时间片过短或过长的问题。

2.使用优先级队列：根据进程的优先级将其加入不同的队列中，从而优先执行高优先级的进程。

3.引入抢占机制：在一些特定情况下，例如优先级较高的进程到达或一些进程的执行时间超过一定阈值，系统可以主动剥夺正在执行的进程的CPU控制权，以保证紧急任务的执行。

计算机操作系统的进程调度算法计算机操作系统是指控制和管理计算机硬件与软件资源的系统软件。

在操作系统中，进程调度算法起着至关重要的作用，它决定了系统中各个进程的执行顺序，合理的调度算法可以提高系统的性能和效率。

本文将对常见的进程调度算法进行介绍和分析。

一、先来先服务调度算法（First-Come, First-Served，FCFS）先来先服务调度算法是最简单的调度算法之一。

按照进程到达的先后顺序依次执行，即抢占后只有等待其他进程执行完毕才能执行。

该算法的优点是简单易实现，但缺点是平均等待时间较长，无法满足实时性要求，容易产生“饥饿”现象。

二、短作业优先调度算法（Shortest Job First，SJF）短作业优先调度算法是通过预测进程执行时间的长短来进行调度的。

当有多个进程同时到达时，选择执行时间最短的进程先执行。

该算法的优点是能够最大限度地减少平均等待时间，但缺点是无法应对长作业的到来，可能导致长作业的等待时间过长。

三、优先级调度算法（Priority Scheduling）优先级调度算法根据进程的优先级来进行调度，优先级高的进程先执行。

该算法可以根据实际需要为不同的进程设置不同的优先级。

该算法的优点是能够满足实时性要求，但缺点是可能导致优先级低的进程长时间等待，产生“饥饿”现象。

四、轮转调度算法（Round Robin，RR）轮转调度算法是一种按照时间片轮流分配CPU的调度算法。

每个进程被分配一个固定的时间片，当时间片用完时，进程被剥夺CPU，并放入就绪队列的末尾等待下一次调度。

该算法的优点是能够公平地分配CPU时间，避免长作业的等待时间过长，缺点是可能导致平均等待时间较长，无法满足实时性要求。

五、多级反馈队列调度算法（Multilevel Feedback Queue，MLFQ）多级反馈队列调度算法是一种综合利用多个调度算法的调度策略。

它将进程划分为多个队列，每个队列采用不同的调度算法。

实验报告：时间片轮转RR进程调度算法题目：时间片轮转算法的实现班级：软件工程2班姓名：代其全学号：1025111022 完成日期：2012/10/23一．需求分析程序要实现时间片轮转进程调度算法（1）接收用户输入的进程数（n）,，各个进程的进程名，到达时间(T1…Tn)和服务时间(S1….Sn)，以及时间片大小q。

（2）输出各个进程首次运行的时间（3）输出各个进程的完成时间，周转时间，带权周转时间，所有进程的平均周转时间，以及带权平均周转时间。

（4）测试数据为: 进程数n为5, 各进程的名字，到达时间，服务时间分别为：a 0 4 ; b 1 3; c 2 5; d 3 2; e 4 4。

时间片大小q为1 和5。

二．概要设计抽象数据类型的定义：int ArrivalTime[100];//到达时间int ServiceTime[100];//服务时间int FinishTime[100];//完成时间int WholeTime[100];//周转时间double WeightWholeTime[100];//带权周转时间double AverageWT,AverageWWT;bool Finished[100];//完成标识typedef struct QNode{char name; //进程标识int arrivaltime;//到达时间int servicetime;//服务时间int workedtime; //进程已经运行的时间bool status; //表示进程的状态,1表示已经结束，0表示还未执行struct QNode *next;}QNode, *QueuePtr;typedef struct{QueuePtr front;//队头指针QueuePtr rear;//队尾指针}LinkQueue;主程序的流程：调用Init()函数初始化到达时间，服务时间，时间片等进程信息，调度RR（）函数实现轮转调度发，最后调度print()函数输出运算结果三．详细设计1.初始化函数void init(){int cputime;int x,y;char name;cout<<"请输入进程的个数:";cin>>n; //进程个数cout<<endl;for(int i=0;i<n;i++){QNode node;cout<<"请输入第"<<i+1<<"个进程的名字、到达时间和服务时间:";cin>>name>>x>>y;=name;node.arrivaltime=ArrivalTime[i]=x;node.servicetime=ServiceTime[i]=y;node.workedtime=0;node.status=Finished[i]=0;node.next=NULL;array[i]=node;//cout<<"队中增加一个元素"<<endl;cout<<endl;}//各个进程的到达时间和服务时间cout<<"请输入时间片大小:";cin>>cputime;q=cputime;//时间片大小}2.RR()函数void RR(){int temp;QNode e;int count1=0;//按到达时间先后排序进程信息数组for(int i=0;i<n;i++){for(int j=1;j<n-i;j++){if(array[i].arrivaltime>array[i+1].arrivaltime){temp=array[i].arrivaltime;array[i].arrivaltime=array[i+1].arrivaltime;array[i].arrivaltime=temp;}}}//此时，array数组中的元素都是按到达时间从小到大排列的for(i=0;i<n;i++){if(Finished[i]==0){count1++;}}for(int j=0;j<n;j++)if(array[j].arrivaltime==currentTime)EnQueue(queue,array[j]);//将到达时间为当前时间的进程加入到队列中if(count1!=0)//依然有进程未完成{for(int j=0;j<n;j++){if(q>=(*queue.front->next).servicetime)//时间片大于进程服务时间时，进程一次性执行完，进入下一进程{//cout<<"";cout<<"时刻"<<currentTime<<":进程"<<queue.front->next->name<<"开始执行"<<endl;for(int x=0;x<(*queue.front->next).servicetime;x++){currentTime++;for(int y=0;y<n;y++)if(array[y].arrivaltime==currentTime)EnQueue(queue,array[y]);//将到达时间为当前时间的进程加入到队列中}(*queue.front).status=1;//将此进程状态标注为已执行// currentTime=currentTime+(*queue.front->next).servicetime;//更新当前时间cout<<"当前时间为:"<<currentTime<<endl;DeQueue(queue,e);//将此进程出队count++;Finished[count]=1;FinishTime[count]=currentTime;//当前时间为完成时间，返回存放入FinishTime[]数组中}else//时间片小于服务时间时{if((*queue.front->next).workedtime<(*queue.front->next).servicetime)//进程已工作时间小于服务时间时{if((*queue.front->next).workedtime==0)//进程已工作时间为零时{// cout<<"";cout<<"时刻"<<currentTime<<":进程"<<(*queue.front->next).name<<"开始执行"<<endl;// currentTime=currentTime+q;//更新当前时间for(int x=0;x<q;x++){currentTime++;for(int j=0;j<n;j++)if(array[j].arrivaltime==currentTime)EnQueue(queue,array[j]);//将到达时间为当前时间的进程加入到队列中}(*queue.front->next).workedtime+=q;//更新进程已工作时间DeQueue(queue,e);//将该进程出队EnQueue(queue,e);//将该进程入队，加入到了队列的末尾}else//进程工作时间不为零且未达到服务时间时{for(inti=0;i<q&&(*queue.front->next).workedtime!=(*queue.front->next).servicetime;i+ +){currentTime++;//当前时间加一for(int j=0;j<n;j++)if(array[j].arrivaltime==currentTime)EnQueue(queue,array[j]);//将到达时间为当前时间的进程加入到队列中if((*queue.front->next).workedtime==(*queue.front->next).servicetime)//已工作时间达到要求的服务时间{(*queue.front->next).status=1;count++;Finished[count]=1;DeQueue(queue,e);FinishTime[count]=currentTime;//当前时间为完成时间，返回存放入FinishTime[]数组中}}}}}}}}3.输出函数void print(int n){cout<<"完成时间:";for(int i=0;i<n;i++)cout<<FinishTime[i]<<" ";cout<<endl;cout<<"周转时间:"<<" ";for(i=0;i<n;i++){WholeTime[i]=FinishTime[i]-ArrivalTime[i];cout<<WholeTime[i]<<" ";}cout<<endl;cout<<"带权周转时间:";for(i=0;i<n;i++){WeightWholeTime[i]=double(WholeTime[i])/ServiceTime[i];cout<<WeightWholeTime[i]<<" ";}cout<<endl;for(i=1;i<n;i++){WholeTime[0]+=WholeTime[i];}AverageWT=double(WholeTime[0])/n;cout<<"平均周转时间"<<AverageWT<<endl;for(i=1;i<n;i++){WeightWholeTime[0]+=WeightWholeTime[i];}AverageWWT=WeightWholeTime[0]/n;cout<<"带权平均周转时间:"<<AverageWWT<<endl; }4.队列里封装的函数int InitQueue(LinkQueue &q){q.front=q.rear=(QueuePtr)malloc(sizeof(QNode));if(!q.front)return 0;q.front->next=NULL;return 1;}int EnQueue(LinkQueue &q,QNode &e){QueuePtr p=(QueuePtr)malloc(sizeof(QNode));if(!p)return 0;p->name=;p->arrivaltime=e.arrivaltime;p->servicetime=e.servicetime;p->status=e.status;p->workedtime=e.workedtime;p->next=NULL;q.rear->next=p;q.rear=p;return 1;}int DeQueue(LinkQueue &q,QNode &e){if(q.rear==q.front)return 0;QueuePtr p=q.front->next;=p->name;e.arrivaltime=p->arrivaltime;e.servicetime=p->servicetime;e.status=p->status;e.workedtime=p->workedtime;q.front->next=p->next;if(q.rear==p)q.rear=q.front;free(p);return 1;}四．调试分析在时间片大于所有进程的服务时间时，程序正常运行，当时间片小于某些进程的服务时间时，程序不能输出正确的运算结果。

RR时间⽚轮转算法（java）操作系统中的时间⽚算法运⾏结果流程图---------------------java代码------------------------package operate;import java.util.LinkedList;import java.util.PriorityQueue;import java.util.Queue;import java.util.Scanner;/*** 时间⽚轮转调度算法* 抢占式，单CPU* @author ymj* @Date： 2019/12/15 23:13*/public class RR {static Scanner cin = new Scanner(System.in);/** 进程控制块 */static class PCB implements Comparable<PCB>{int id; // 进程idint arriveTime; // 到达时间int runTime; // 运⾏时间int hasRanTime = 0; // 已经运⾏时间，初始值为0int turnAroundTime; // 周转时间int waitTime; // 等待时间int responseTime;// 响应时间 == ⾸次运⾏时间-到达时间PCB(int id, int arriveTime, int runTime){this.id = id;this.arriveTime = arriveTime;this.runTime = runTime;}@Overridepublic int compareTo(PCB o) { // 按照到达时间进⼊就绪队列return this.arriveTime - o.arriveTime;}}static PCB[] pcbs; // 进程数组static int timeSlice; // 时间⽚/** 进程到达队列 */static Queue<PCB> queue = new PriorityQueue<>();/** 初始化 PCB 信息 */static void initPCB(){System.out.print("输⼊进程数： ");int num = cin.nextInt();pcbs = new PCB[num+1];System.out.println("输⼊到达时间，运⾏时间");for(int i = 1; i <= num; i++) {System.out.print("进程" + i + ":");pcbs[i] = new PCB(i, cin.nextInt(), cin.nextInt());queue.offer(pcbs[i]);}System.out.print("输⼊时间⽚⼤⼩：");timeSlice = cin.nextInt();}/** 判断当前已经到达的进程，并使之进⼊就绪队列 */static boolean judge(Queue<PCB> readyQueue, int currentTime){boolean flag = false; // 为 true 表⽰有到达的进程while (true){PCB pcb = queue.peek(); // 最先到达的进程if (pcb == null){ // 所有进程都已经进⼊了就绪队列break;}else if(pcb.arriveTime <= currentTime){ // 当前有进程到达PCB runPCB = queue.poll();readyQueue.offer(runPCB); // 进⼊就绪队列等待运⾏flag = true;}else { // 当前没有进程到达break;}}return flag;}/** 进程进⼊处理机运⾏, 如果进程运⾏完成返回 true*/static boolean processRun(PCB pcb, int currentTime){if(pcb.hasRanTime == 0){ // 进程⾸次运⾏时间pcb.responseTime = currentTime;}pcb.hasRanTime++; // 进⼊处理机运⾏System.out.printf(" %d\n", pcb.id);if(pcb.hasRanTime == pcb.runTime){ // 进程已经结束pcb.turnAroundTime = currentTime+1 - pcb.arriveTime; // 周转时间pcb.waitTime = pcb.turnAroundTime - pcb.runTime; // 等待时间pcb.responseTime -= pcb.arriveTime;return true;}else {return false;}}/** 处理机运⾏ */static void run() {int currentTime = 0; // 当前时间if(!queue.isEmpty()){currentTime = queue.peek().arriveTime;}/** 定义就绪队列 */Queue<PCB> readyQueue = new LinkedList<>();int timeSliceFlag = timeSlice; // 时间⽚标记（假设刚开始是⼀个时间⽚的开始）PCB runPcb = null;System.out.println("now 正在运⾏的进程");while (true) {System.out.printf("%d\t ", currentTime);if(queue.isEmpty() && readyQueue.isEmpty() && runPcb== null){System.out.println("当前所有进程运⾏结束");break;}else{ // 进程进⼊处理机运⾏/** 判断是否到⼀个时间⽚ */if(timeSliceFlag % timeSlice == 0){ // ⼀个时间⽚到/** 判断当前已经到达的进程，并使之进⼊就绪队列 */judge(readyQueue, currentTime);if(runPcb != null){ // 处理机上还有进程// 此时要下处理机，进⼊就绪队列readyQueue.offer(runPcb);runPcb = null; // 此时处理机空闲}runPcb = readyQueue.poll(); // 出就绪队列，if(runPcb == null){ // 就绪队列为空, 意味着此时处理机空闲，⽽且没有到达的进程 currentTime++; // 处理机等待System.out.printf(" 处理机空闲,\n");continue; // 进⼊下⼀轮}}/** 在处理机中运⾏进程-->runPCB*/if(processRun(runPcb, currentTime) == true){ // 运⾏后进程已经结束runPcb = null;timeSliceFlag = timeSlice; // 重新开始⼀个新的时间⽚}else { // 进程没有结束timeSliceFlag++;}/** 时间⽚+1 */currentTime++;}}}public static void main(String[] args) {initPCB();System.out.println("-----处理机开始运⾏-----");run();System.out.println("-----处理机运⾏结束-----");showTurnAroundTime();}// 周转时间private static void showTurnAroundTime() {double averageT = 0;double averageWTAT = 0;double averageWT = 0;System.out.println("进程\t 周转时间\t 带权周转时间\t 等待时间\t 响应时间\t");for (int i = 1; i < pcbs.length; i ++) {int turnAroundTime = pcbs[i].turnAroundTime;double weightTurnAroundTime = turnAroundTime*1.0/pcbs[i].runTime;int waitTime = pcbs[i].waitTime;int responseTime = pcbs[i].responseTime;System.out.printf("%d\t %d\t\t\t %.2f\t\t\t %d\t\t\t %d\n" ,i , turnAroundTime, weightTurnAroundTime, waitTime, responseTime); averageT += turnAroundTime;averageWTAT += weightTurnAroundTime;averageWT += waitTime;}averageT /= pcbs.length-1;averageWTAT /= pcbs.length-1;averageWT /= pcbs.length-1;System.out.println("平均周转时间：" + averageT);System.out.printf("平均带权周转时间：%.2f\n", averageWTAT);System.out.println("平均等待时间：" + averageWT);}}。

操作系统各种调度算法操作系统的调度算法是操作系统中的重要组成部分，它决定了进程在CPU上的执行顺序和调度策略。

不同的调度算法应用于不同的场景和需求，目的是提高CPU利用率、降低响应时间、提高吞吐量等。

本文将介绍几种常见的调度算法，包括先来先服务调度算法（FCFS）、最短作业优先调度算法（SJF）、时间片轮转调度算法（RR）和多级反馈队列调度算法（MFQ）。

先来先服务调度算法（FCFS）是最简单的调度算法之一，该算法按照进程到达的先后顺序分配CPU资源。

当一个进程在CPU上执行时，其他进程需要等待，直到该进程完成。

FCFS调度算法具有易于实现和公平性的优点，但是由于没有考虑进程的执行时间，可能导致长作业的久等和短作业的饥饿问题。

最短作业优先调度算法（SJF）根据进程的预计执行时间来调度。

该算法假设可以获得每个进程的执行时间，并选择执行时间最短的进程执行。

SJF调度算法可以最小化平均等待时间和响应时间，但是由于无法准确预测进程的执行时间，可能导致长作业的饥饿问题。

时间片轮转调度算法（RR）将CPU时间切分成固定长度的时间片，每个进程在一个时间片中执行。

当一个进程的时间片用完后，系统将该进程重新加入到就绪队列的末尾，让其他就绪进程获得CPU执行。

RR调度算法能够保证每个进程都能获得一定的CPU时间，但是当进程的执行时间过长时，可能需要频繁的上下文切换，导致系统开销增加。

多级反馈队列调度算法（MFQ）是一种结合了FCFS和RR的调度算法。

该算法将就绪队列划分成多个队列，每个队列有不同的优先级，并且每个队列采用RR调度算法。

进程首先进入高优先级队列，如果时间片用完仍未完成，则降低优先级进入下一级队列，直到最低优先级队列。

此时，进程将拥有更长的时间片并能够执行较长时间。

MFQ调度算法兼顾了短作业的优先执行和长作业的公平性，但是需要根据实际情况设置多个队列和时间片长度，较为复杂。

除了以上介绍的几种调度算法，还有其他一些调度算法可供选择，如最高响应比优先调度算法（HRRN）、最早截止时间优先调度算法（EDF）等。

Java实现进程调度算法（⼆）RR（时间⽚轮转）⼀、概述 因为这次os作业对⽤户在控制台的输⼊输出有要求，所以我花了挺多的代码来完善控制台的显⽰。

也因为我这次要实现多个类似算法，所以将⼀些共性单独提取出来作为⼀个类。

如果只想要和算法有关的核⼼代码，看RR类的calc()即可。

实现思路：每运⾏⼀个进程，则将所有进程的remainServiceTime减去⼀个时间⽚的长度。

⼆、运⾏结果 1. 测试数据： 2. 运⾏结果：三、流程图四、实现代码 1. RR类（主类）只有calc()中涉及了算法，init()和printResult()只有简单的输⼊输出操作。

1package xqy.algorithm;23import java.util.*;45import xqy.Util.Tools;6import xqy.been.Process;78/**9 * @author xqy10 * @date 2018年12⽉19⽇19:14:4911*/12public class RR {13private int processNumber;14private ArrayList<Process> processList;15private int timeSlice;1617public RR() {18 init();19 calc();20 Tools.printResult(processList);21 }2223private void init() {24 Scanner sc = new Scanner(System.in);2526 System.out.print("<RR> Please enter the slice time:");27 timeSlice = sc.nextInt();28 System.out.print("<RR> please enter the process num:");29 processNumber = sc.nextInt();3031 processList = new ArrayList<Process>();32for (int i = 0; i < processNumber; i++) {33 processList.add(new Process());34 }3536 System.out.println("<RR> Please enter each process arrival time:");37for (int i = 0; i < processNumber; i++) {38 System.out.print(" Process" + (i + 1) + ":");39 processList.get(i).setArrivalTime(sc.nextInt());40 }4142 System.out.println("<RR> Please enter each process service time:");43for (int i = 0; i < processNumber; i++) {44 System.out.print(" Process" + (i + 1) + ":");45int servicesTime = sc.nextInt();4647 processList.get(i).setServicesTime(servicesTime);48 processList.get(i).setRemainServiceTime(servicesTime);49 }50 }5152private void calc() {53int timeNow = 0;54int processRemain = processNumber;55boolean noProcessRunInThisTurn;56 Process opProcess;5758while (processRemain != 0) {59 noProcessRunInThisTurn = true;6061for (int i = 0; i < processNumber; i++) {62 opProcess = processList.get(i);6364if ((opProcess.getRemainServiceTime() > 0)65 && (timeNow >= opProcess.getArrivalTime())) {66// First time67if (opProcess.getServicesTime() == opProcess68 .getRemainServiceTime()) {69int waitTime = timeNow - opProcess.getArrivalTime();7071 opProcess.setStartTime(timeNow);72 opProcess.setWaitTime(waitTime);73 }7475// Calculating remain service time76int remainServiceTime = opProcess.getRemainServiceTime()77 - timeSlice;78 opProcess.setRemainServiceTime(remainServiceTime);7980// Last time81if (remainServiceTime <= 0) {82int completionTime = timeNow + timeSlice; // The process ends when the current slice is completed. 83int turnAroundTime = completionTime84 - opProcess.getArrivalTime();85double turnAroundTimeWithWeight = 1.0 * turnAroundTime86 / opProcess.getServicesTime();8788 opProcess.setCompletionTime(completionTime);89 opProcess.setTurnAroundTime(turnAroundTime);90 opProcess91 .setTurnAroundTimeWithWeight(turnAroundTimeWithWeight);92 processRemain--;93 }9495 timeNow += timeSlice;96 noProcessRunInThisTurn = false;9798 System.out.println(" #STEP# Process" + (i + 1)99 + " remain service time:"100 + opProcess.getRemainServiceTime()101 + " , timeBefore:" + (timeNow - 1) + ", timeNow:"102 + timeNow103 + ((remainServiceTime <= 0) ? " Finish" : ""));104 } else {105// do noting, because this process has been completed or hasn`t arrived.106 }107 }108109// Means no process could run, because they have arrived.110if ((processRemain > 0) && noProcessRunInThisTurn) {111 timeNow += timeSlice;112 }113 }114 }115 } 2. Process类模拟了进程，对属性进⾏了封装。

操作系统中的进程调度算法随着现代计算机技术的不断发展，操作系统成为管理计算机系统的核心组件。

操作系统不仅可以控制计算机硬件和软件资源的分配，还可以提高计算机的效率和管理性能。

而进程调度就是操作系统中最重要的功能之一，其目的是实现多个进程之间的均衡，响应用户请求，最大程度的利用计算机资源。

进程调度算法是指操作系统中用来决定哪个进程可以被执行和运行多长时间的算法。

不同的操作系统有不同的进程调度算法，通常根据不同策略来选择进程。

下面将介绍几种经典的进程调度算法。

1. 先来先服务（FCFS）算法FCFS算法是最简单的进程调度算法之一。

它的核心思想是按照进程到达的顺序排队，当一个进程结束执行后，下一个进程将会自动成为就绪队列中的第一个进程。

这种算法的优点在于简单易实现，但是很容易出现长作业长等待的问题，也就是说长时间在等待队列中的进程可能会影响到系统效率。

2. 最短作业优先（SJF）算法SJF算法通过对进程执行时间的估计来决定下一个要执行的进程。

也就是说，当一个新进程加入系统时，选择预计需要最短执行时间的进程进行调度。

这种算法在情况比较稳定时，可以保证平均等待时间最少。

但是当有大量的短作业成批到达时，长作业就可能会一直等待。

3. 优先级算法优先级算法是按照每个进程的优先级确定执行顺序的算法。

通常情况下，优先级由进程的重要性、紧急程度等因素来决定。

优先级越高的进程会先得到执行机会。

这种算法可以保证重要的进程得到优先执行，但是它也存在一个问题：优先级调度可能会导致低优先级的进程一直等待执行，这就是由于饥饿现象的出现。

4. 时间片轮转算法时间片轮转算法是一种按照时间分配资源的算法。

每个进程都被分配一个时间片，在该时间片结束时，操作系统会强制暂停进程的执行，将CPU时间分配给下一个进程执行。

这种算法可以保证每个进程都有机会得到尽可能的执行时间，而且能够避免长时间的等待。

5. 高响应比优先（HRRN）算法HRRN算法是一种综合了SJF和优先级算法的综合调度算法。

电子科技大学实验报告学生姓名：满博学号：2823103017 指导教师：罗惠琼一、实验室名称：软件实验室A2412二、实验项目名称：进程调度算法的设计（时间片轮转调度算法RR）说明：同时采用了新旧教材的RR算法（两种算法都在实验报告中给出）三、实验原理：在多道程序系统中，一个作业被提交后必须经过处理机调度后，方能获得处理机执行。

对调度的处理又都可采用不同的调度方式和调度算法。

调度算法是指：根据系统的资源分配策略所规定的资源分配算法。

RR算法：每次调度时，把CPU分配给队首进程，并且令其执行一个时间片，时间片的大小从几个ms到几百ms。

当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便依据此信号来停止该进程的执行；并且把它送往就绪队列的队尾；然后，再把处理剂分配给就绪队列中的新队首进程，同时也让它执行一个时间片。

这样就可以保证就绪队列中的所有进程在一个给定时间内均能获得一时间片的处理机执行时间。

换言之，系统能在给定的时间内相应所有用户的请求。

四、实验目的：通过对进程调度算法的设计，深入理解进程调度的原理。

五、实验内容：1. 编写ＲＲ算法。

进程通过定义一个进程控制块的数据结构（PCB）来表示；●每个进程需要赋予进程ID、进程到达时间、进程需要运行的总时间的属性；●以1为时间片单位；2. 调试无误后运行。

3. 输入需要请求调入的页号。

4. 查看执行结果，根据执行结果判断实验是否成功。

六、实验器材（设备、元器件）：1．基本环境要求①宽敞整洁专用实验室②必备的基本实验工具2．最低设备要求①计算机CPU不小于800MHZ；②计算机内存不小于128M；3．软硬件要求①实验平台Visual c++ 6.0七、实验步骤：1．新教材RR代码：#include<stdio.h>#define n 5#define num 5#define max 65535typedef struct pro{int PRO_ID;int arrive_time;int sum_time;int flag;}Pro;void RR(int p){int i,j,c=0;int count=num;int timer=0;Pro seq[n],t;Pro temp_seq[n];for(i=0;i<n;i++){temp_seq[i].PRO_ID=0;temp_seq[i].arrive_time=-1;temp_seq[i].sum_time=0;temp_seq[i].flag=0;}printf("轮转时间片调度算法RR\n");printf("请依次输入%d个进程的进程号、到达时间和执行时间\n",n);printf("成员变量用逗号隔开；进程间用回车隔开\n");for(i=0;i<n;i++){scanf("%d,%d,%d",&seq[i].PRO_ID,&seq[i].arrive_time,&seq[i].sum_time);}//第一个初始化for(i=0;i<n;i++){if(timer==seq[i].arrive_time){temp_seq[0]=seq[i];temp_seq[0].flag=1;c++;timer++;break;}}//开始循环while(count){int flag=0;if(temp_seq[0].flag){printf("%d",temp_seq[0].PRO_ID);temp_seq[0].sum_time--;if(temp_seq[0].sum_time==0&&temp_seq[0].flag!=0){count--;temp_seq[0].flag=0;}for(i=0;i<5;i++){if(timer==seq[i].arrive_time){t=temp_seq[0];temp_seq[c]=seq[i];for(j=0;j<c;j++){temp_seq[j]=temp_seq[j+1];}temp_seq[c]=t;c++;flag=1;}}}if(flag!=1){t=temp_seq[0];for(i=0;i<c;i++){temp_seq[i]=temp_seq[i+1];}temp_seq[c]=t;}timer++;}}void main(){RR(n);}2．旧教材RR代码：#include<stdio.h>#define n 5#define num 5#define max 65535#include<math.h> typedef struct pro{int PRO_ID;int arrive_time;int sum_time;int flag;}Pro;//整数排序int bubble(int temp[]){int i,j,tem=0;for(i=1;i<num;i++){int lastX=1;for(j=0;j<num-i;j++){if(temp[j]>temp[j+1]){tem=temp[j];temp[j]=temp[j+1];temp[j+1]=tem;lastX=0;}}if(lastX==1) break;}return temp[0];}//进程排序void bubble(Pro s[]){int i,j;Pro temp={0};for(i=1;i<num;i++){int lastX=1;for(j=0;j<num-i;j++){if(s[j].arrive_time>s[j+1].arrive_time){temp=s[j];s[j]=s[j+1];s[j+1]=temp;lastX=0;}}if(lastX==1) break;}}void PCB(int p){if(n>0){int i;Pro seq[n];printf("旧教材轮转时间片调度算法RR\n");printf("请依次输入%d个进程的进程号、到达时间和执行时间\n",n);printf("成员变量用逗号隔开；进程间用回车隔开\n");for(i=0;i<n;i++){scanf("%d,%d,%d",&seq[i].PRO_ID,&seq[i].arrive_time,&seq[i].sum_time);}bubble(seq);/* for(i=0;i<num;i++){printf("%d,%d,%d\t",seq[i].PRO_ID,seq[i].arrive_time,seq[i].sum_time);}*/for(i=0;i<num;i++){if(seq[i].sum_time!=0){printf("%d",seq[i].PRO_ID);seq[i].sum_time--;seq[i].flag=1;}if((i+1)==num) i=-1;}printf("\n\b");}}void main(){PCB(n);}旧教材RR结果截图如下：旧教材实例新教材RR结果截图如下：新教材实例八、实验数据及结果分析：新旧RR算法的结果都与新旧教材的结果相同，RR算法功能已实现。

时间片轮转调度算法是操作系统中常用的调度算法之一，它能够有效地分配CPU时间片给各个进程，从而实现公平地对待所有进程，并降低响应时间。

1. 时间片轮转调度算法的基本原理时间片轮转调度算法是一种基于时间片的轮询调度算法。

它将每个进程分配一个小的时间片，当一个进程的时间片用完了，操作系统将其移到就绪队列的末尾，并将CPU分配给下一个进程。

这样，所有进程都能获得公平的CPU时间，而且在短时间内能够得到响应。

2. 时间片轮转调度算法的实现在Java中，我们可以通过使用队列来实现时间片轮转调度算法。

我们需要定义一个进程类，该类包含进程的ID、CPU时间和已经执行的时间等属性。

我们创建一个就绪队列，将所有进程按照它们到达的顺序加入队列中。

我们使用一个循环来模拟时间片的轮转，当一个进程的时间片用完后，将其移到队列的末尾，并将CPU分配给队列中的下一个进程。

3. 时间片轮转调度算法的优缺点时间片轮转调度算法的优点是能够公平地分配CPU时间，每个进程都能够在短时间内得到响应。

而且，它能够减少进程的等待时间，提高系统的响应速度。

但是，时间片轮转调度算法也存在着一些缺点，比如对于I/O密集型的进程来说，由于频繁地切换进程，可能会导致额外的开销。

4. 个人观点和理解时间片轮转调度算法是一种简单有效的调度算法，特别适用于多用户、交互式的系统。

在实际的应用中，我们可以根据系统的特点和需求来选择合适的调度算法，以达到更好的性能和用户体验。

总结回顾：时间片轮转调度算法是一种重要的调度算法，它能够有效地分配CPU时间，并提高系统的响应速度。

在Java中，我们可以通过使用队列来实现时间片轮转调度算法。

虽然它有一些缺点，但是在多用户、交互式的系统中仍然具有重要的应用意义。

选择合适的调度算法对系统的性能和用户体验都非常重要。

时间片轮转调度算法是一种在操作系统中常用的调度算法，它能够有效地分配CPU时间片给各个进程，从而实现对所有进程的公平处理，并降低系统的响应时间。

操作系统实验报告实验二时间片轮转进程调度算法学号：班级：姓名:【实验题目】：时间片轮转进程调度算法【实验目的】通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

【实验内容】问题描述：设计程序模拟进程的时间片轮转RR调度过程。

假设有n个进程分别在T1, … ,T n时刻到达系统，它们需要的服务时间分别为S1, … ,S n。

分别利用不同的时间片大小q，采用时间片轮转RR进程调度算法进行调度，计算每个进程的完成时间，周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。

程序要求如下：1）进程个数n；每个进程的到达时间T1, … ,T n和服务时间S1, … ,S n；输入时间片大小q。

2）要求时间片轮转法RR调度进程运行，计算每个进程的周转时间，带权周转时间，并且计算所有进程的平均周转时间，带权平均周转时间；3）输出：要求模拟整个调度过程，输出每个时刻的进程运行状态，如“时刻3：进程B开始运行”等等；4）输出：要求输出计算出来的每个进程的周转时间，带权周转时间，所有进程的平均周转时间，带权平均周转时间。

实现提示：用C++语言实现提示：1）程序中进程调度时间变量描述如下：int ArrivalTime[100];int ServiceTime[100];int PServiceTime[100];int FinishTime[100];int WholeTime[100];double WeightWholeTime[100];double AverageWT,AverageWWT;bool Finished[100];2）进程调度的实现过程如下：➢变量初始化；➢接收用户输入n，T1, … ,T n，S1, … ,S n；时间片大小q；➢按照时间片轮转RR算法进行进程调度，计算进程的完成时间、周转时间和带权周转时间；➢计算所有进程的平均周转时间和平均带权周转时间；➢按格式输出调度结果。