实验二时间片轮转RR进程调度算法

操作系统实验报告进程调度操作系统实验报告：进程调度引言在计算机科学领域中，操作系统是一个重要的概念，它负责管理和协调计算机系统中的各种资源，包括处理器、内存、输入/输出设备等。

其中，进程调度是操作系统中一个非常重要的组成部分，它负责决定哪个进程在何时获得处理器的使用权，以及如何有效地利用处理器资源。

实验目的本次实验的目的是通过对进程调度算法的实验，深入理解不同的进程调度算法对系统性能的影响，并掌握进程调度算法的实现方法。

实验环境本次实验使用了一台配备了Linux操作系统的计算机作为实验平台。

在该计算机上，我们使用了C语言编写了一些简单的进程调度算法，并通过模拟不同的进程调度场景进行了实验。

实验内容1. 先来先服务调度算法（FCFS）先来先服务调度算法是一种简单的进程调度算法，它按照进程到达的顺序进行调度。

在本次实验中，我们编写了一个简单的FCFS调度算法，并通过模拟多个进程同时到达的情况，观察其对系统性能的影响。

2. 短作业优先调度算法（SJF）短作业优先调度算法是一种根据进程执行时间长度进行调度的算法。

在本次实验中，我们编写了一个简单的SJF调度算法，并通过模拟不同长度的进程，观察其对系统性能的影响。

3. 时间片轮转调度算法（RR）时间片轮转调度算法是一种按照时间片大小进行调度的算法。

在本次实验中，我们编写了一个简单的RR调度算法，并通过模拟不同时间片大小的情况，观察其对系统性能的影响。

实验结果通过实验，我们发现不同的进程调度算法对系统性能有着不同的影响。

在FCFS 算法下，长作业会导致短作业等待时间过长；在SJF算法下，长作业会导致短作业饥饿现象；而RR算法则能够较好地平衡不同进程的执行。

因此，在实际应用中，需要根据具体情况选择合适的进程调度算法。

结论本次实验通过对进程调度算法的实验，深入理解了不同的进程调度算法对系统性能的影响，并掌握了进程调度算法的实现方法。

同时，也加深了对操作系统的理解，为今后的学习和研究打下了良好的基础。

进程调度算法实验报告进程调度算法实验报告一、引言进程调度算法是操作系统中的重要组成部分，它决定了进程在CPU上的执行顺序。

合理的进程调度算法能够提高系统的性能和效率，使得多个进程能够公平地共享CPU资源。

本实验旨在通过实际操作和数据分析，探究不同的进程调度算法对系统性能的影响。

二、实验方法1. 实验环境本次实验使用了一台配置较高的计算机作为实验环境，操作系统为Windows 10。

实验中使用了C语言编写的模拟进程调度程序。

2. 实验步骤（1）编写模拟进程调度程序，实现常见的进程调度算法，包括先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）和优先级调度（Priority）。

（2）设计一组测试用例，包括不同执行时间的进程和不同优先级的进程。

（3）运行模拟进程调度程序，记录每个进程的等待时间、周转时间和响应时间。

（4）根据实验结果分析不同进程调度算法的性能差异。

三、实验结果与分析1. 先来先服务（FCFS）调度算法先来先服务调度算法按照进程到达的先后顺序进行调度，即先到达的进程先执行。

实验结果显示，该算法对于执行时间较短的进程表现良好，但对于执行时间较长的进程则存在明显的不公平性。

长作业的等待时间较长，导致整体执行效率较低。

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

实验结果显示，该算法能够最大程度地减少平均等待时间和周转时间，提高系统的执行效率。

然而，该算法对于执行时间较长的进程存在饥饿问题，即长作业可能一直等待短作业的执行，导致长作业的等待时间过长。

3. 时间片轮转（RR）调度算法时间片轮转调度算法将CPU的执行时间划分为固定长度的时间片，每个进程按照轮流执行的方式进行调度。

实验结果显示，该算法能够保证每个进程都能够获得一定的执行时间，提高了系统的公平性。

然而，对于执行时间较长的进程而言，由于需要等待其他进程的轮转，其执行效率相对较低。

实验二时间片轮转算法实验报告一、实验目的本次实验的主要目的是了解时间片轮转算法的工作原理，学习如何使用时间片轮转算法进行进程调度，并了解时间片大小对进程调度的影响。

二、实验原理时间片轮转算法是一种公平的进程调度算法，它采用循环队列的形式，将所有需要运行的进程按照到达时间排序，并将它们按照轮转的方式依次执行，每个进程在一个时间片内执行一定的时间（时间片大小），然后被暂停并放在队列的末尾等待下一次调度。

当一个进程的时间片用完后，它会被暂停并放在队列的最后，而在这个时间片内没有执行完的进程会被暂停并放到队列的开头，以便继续下一轮的运行。

这样一直循环下去，直到所有进程都运行完毕。

三、实验步骤1.设定进程数量和时间片大小。

2.定义进程结构体，包括进程ID、到达时间、服务时间、剩余时间等信息。

3.初始化所有进程，并按照到达时间排序。

4.创建一个循环队列，并将所有已到达的进程入队。

5.按照时间片大小循环执行以下步骤：a.从队列中取出一个进程，执行一次时间片大小的时间。

b.更新队列中所有进程的剩余时间。

c.如果剩余时间大于0，将进程放入队尾。

d.如果剩余时间等于0，表示进程执行完毕，将其从队列中移除。

e.输出每个时间片的调度情况。

6.统计平均等待时间和平均周转时间，并输出结果。

四、实验结果本次实验我们设置了4个进程，并且时间片大小为3、以下是每个时间片的调度情况：时间片1：进程1执行，剩余时间为2时间片2：进程2执行，剩余时间为4时间片3：进程3执行，剩余时间为5时间片4：进程1执行，剩余时间为1时间片5：进程2执行，剩余时间为3时间片6：进程3执行，剩余时间为4时间片7：进程4执行，剩余时间为2时间片8：进程1执行，剩余时间为0，进程1执行完毕时间片9：进程2执行，剩余时间为2时间片10：进程3执行，剩余时间为3时间片11：进程4执行，剩余时间为1时间片12：进程2执行，剩余时间为1时间片13：进程3执行，剩余时间为2时间片14：进程4执行，剩余时间为0，进程4执行完毕时间片15：进程2执行，剩余时间为0，进程2执行完毕时间片16：进程3执行，剩余时间为1时间片17：进程3执行，剩余时间为0根据以上调度情况，我们可以计算出平均等待时间和平均周转时间。

实验二时间片轮转RR进程调度算法一: 需求分析(1)程序的设计的任务和目的：设计程序模拟进程的时间片轮转RR调度过程。

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

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

(2)通过这次实验, 加深对进程概念的理解, 进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

(3)输入的形式和输入值的范围为避免测试时频繁输入数据, 将测试数据放在txt文件中采用读文件方法读取数据。

在同目录下的txt文件中输入数据, 第一行为进程到达时间, 中间用空格隔开, 第二行为进程服务时间, 不同进程的服务时间之间用空格隔开。

(2) 输出的形式输出每个时刻的进程运行状态, 并且输出计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。

（详见运行截图）(3) 程序所能达到的功能；详见运行结果截图2、概要设计使用链表创建队列, 用链表方法实现时间片轮转调度。

主要有主函数, 时间片轮转调度函数void RR(int*ArrivalTime,int*ServiceTime,int n,int q,LinkQueue &Q)和输出函数voidprint(int n,int array[]), void print(int n,double array[])；三: 详细设计时间片轮转算法流程图:程序主要设计思想:（1）创建进程, 使用链表的方法, 链表中的每个结点相当于一个进程。

（2）读入文件中进程数据（进程的到达时间和服务时间）。

（3）创建一个进程单链表, 作为进程队列。

（4）请用户输入时间片大小。

（5）创建执行队列。

（6）定义时间轴, 初始化时间轴和执行队列。

进程调度实验报告进程调度实验报告概述：进程调度是操作系统中一个重要的组成部分，它负责决定在多个进程同时运行时，每个进程分配到的CPU时间片以及切换进程的时机。

合理的进程调度算法能够提高系统的性能和资源利用率，因此对进程调度的研究和优化具有重要意义。

1. 背景介绍进程调度是操作系统中的一个关键任务，它负责管理和控制多个进程的执行顺序，以实现对CPU的合理分配。

在多道程序设计环境下，进程调度的作用尤为重要。

进程调度算法的好坏直接影响着系统的性能和响应速度。

2. 进程调度算法2.1 先来先服务（FCFS）先来先服务是最简单的调度算法之一，它按照进程到达的先后顺序进行调度，即先到达的进程先执行，直到该进程执行完成或者发生I/O操作。

FCFS算法的优点是公平且易于实现，但是它无法适应不同进程的执行时间差异，可能导致长作业效应。

2.2 最短作业优先（SJF）最短作业优先调度算法是根据进程的执行时间长度来进行调度，执行时间越短的进程越优先执行。

SJF算法能够最大程度地减少平均等待时间，但是它需要预先知道进程的执行时间，这在实际应用中往往是不可行的。

2.3 时间片轮转（RR）时间片轮转是一种经典的调度算法，它将CPU的执行时间划分为若干个时间片，每个进程在一个时间片内执行，如果时间片用完还没有执行完，则将该进程放入就绪队列的末尾，继续执行下一个进程。

RR算法能够保证每个进程都能获得公平的CPU时间，但是对于长时间执行的进程，会导致较大的上下文切换开销。

3. 实验设计与结果分析为了评估不同进程调度算法的性能，我们设计了一系列实验。

首先，我们使用不同的进程到达时间和执行时间生成一组测试数据。

然后，分别使用FCFS、SJF和RR算法进行调度，并记录每个进程的等待时间和周转时间。

最后，我们对实验结果进行分析。

实验结果显示，FCFS算法对于执行时间较长的进程会出现较长的平均等待时间，而SJF算法能够有效减少平均等待时间。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

时间⽚轮转调度算法实验⼆时间⽚轮转调度算法实验内容：模拟实现时间⽚轮转调度算法，具体如下：设置进程体：进程名，进程的到达时间，服务时间，，进程状态（W——等待,R——运⾏,F ——完成），进程间的链接指针进程初始化：由⽤户输⼊进程名、服务时间进⾏初始化，同时，初始化进程的状态为W。

显⽰函数：在进程调度前、调度中和调度后进⾏显⽰。

排序函数：对就绪状态的进程按照进⼊就绪队列的时间排序，新到达的进⾏应优先于刚刚执⾏过的进程进⼊就绪队列的队尾。

注意考虑到达时间调度函数：每次从就绪队列队⾸调度优⼀个进程执⾏，状态变化。

并在执⾏⼀个时间⽚后化，服务时间变化，状态变化。

当服务时间为0时，状态变为F。

删除函数：撤销状态为F的进⾏。

实验要求：1、测试数据可以随即输⼊或从⽂件中读⼊。

2、必须要考虑到进程的到达时间3、最终能够计算每⼀个进程的周转时间的带权周转时间。

实验代码：#include#include#includeusing namespace std;int n;class PCB{public:int pri;int runtime;int pieceOftime;string procname;string state;int needOftime;int Counter;PCB * next;};PCB * run = NULL;PCB * finish = NULL;PCB * tial = ready;void Dtime(int t);void Prinft(int a){if(a==1){cout<<"\n进程名\t到达时间\t服务时间\t时间⽚\t进程状态"<}}void Prinft(int b,PCB * p){if(b==1){cout<procname<<"\t"<needOftime<<"\t\t"<runtime<<"\t\t"<pieceOftime<<"\t"<state< }}void display(int c){PCB *p;if(run!=NULL)Prinft(c,run);p=ready;while(p!=NULL){Prinft(c,p);p=p->next;}p=finish;while(p!=NULL){Prinft(c,p);p=p->next;}void insert(PCB *p){PCB *S1,*S2;if(ready==NULL){p->next = NULL;ready = p;}else{S1 = ready;S2 = S1;while(S1!=NULL){if(S2->pri >= p->pri){S2->next = p;p->next = S1;}else{p->next = ready;ready = p;}}}}bool CTProcessOfPri(){PCB * Node;cout <<"输⼊创建进程的数⽬:"< cin >>n;for(int j = 0;j < n; j++)Node = new PCB;if(Node==NULL)return false;else{cout <<"输⼊进程的名称,进程需CPU时间:"< cin >>Node->procname>>Node->needOftime; Node->runtime = 0;Node->state ="就绪";Node->pri =Node->needOftime;cout <<"进程"<procname<<"创建完毕!"<}insert(Node);}return true;}void priority(int i){run = ready;ready = ready->next;run->state = "运⾏";Prinft(i);while(run!=NULL){run->runtime=run->runtime+1;run->needOftime=run->needOftime-1;run->pri=run->pri-1;if(run->needOftime==0){run->state = "完成";run->next = finish;finish = run;run=NULL;if(ready!=NULL)run = ready;run->state = "运⾏";ready = ready->next;}}else if((ready!=NULL)&&(run->pripri)) {run->state="就绪";insert(run);run = ready;run->state = "运⾏";ready = ready->next;}display(i);}}void queue(PCB *p){if(ready==NULL){p->next = NULL;ready = p;tial = p;}else{tial->next = p;tial = p;p->next = NULL;}}bool CTProcessOfRuntime(){PCB * Node;cout <<"输⼊创建进程的数⽬:"<cin >>n;cout <<"输⼊时间⽚:"<cin >>m;for(int j = 0;j < n; j++){Node = new PCB;if(Node==NULL)return false;else{cout <<"输⼊进程的名称,进程需CPU时间:"< cin >>Node->procname>>Node->needOftime; Node->runtime = 0;Node->state ="就绪";Node->Counter = 0;Node->pieceOftime = m;cout <<"进程"<procname<<"创建完毕!"<}queue(Node);}return true;}void Runtime(int c){run = ready;ready = ready->next;run->state = "运⾏";Prinft(c);while(run!=NULL){run->runtime=run->runtime+1;run->needOftime=run->needOftime-1;run->Counter = run->Counter + 1;{run->state = "完成";run->next = finish;finish = run;run = NULL;if(ready!=NULL){run = ready;ready = ready->next;}}else if(run->Counter == run->pieceOftime){run->Counter = 0;run->state = "就绪";queue(run);run=NULL;if(ready!=NULL){run = ready;run->state = "运⾏";ready = ready->next;}}display(c);}}int main(){int i;cout <<"----------时间⽚轮转调度算法---------"< cout <<"--------- 1 开始 2 退出---------\n\n选择:"< cin >>i;switch(i)case 1: CTProcessOfRuntime(); Runtime(i);break;case 2:break;}return 0;}void Dtime(int t){time_t current_time;time_t start_time;time(&start_time);do{time(& current_time);}while((current_time-start_time)实验结果：。

时间片轮转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控制权，以保证紧急任务的执行。

进程调度模拟程序实验实验报告一、实验目的进程调度是操作系统的核心功能之一，它负责合理地分配 CPU 资源给各个进程，以提高系统的性能和效率。

本次实验的目的是通过编写和模拟进程调度程序，深入理解不同的进程调度算法的原理和特点，并比较它们在不同情况下的性能表现。

二、实验环境本次实验使用的编程语言为 Python，开发环境为 PyCharm。

操作系统为 Windows 10。

三、实验原理1、先来先服务（FCFS）调度算法先来先服务调度算法按照进程到达的先后顺序进行调度，先到达的进程先获得 CPU 资源。

2、短作业优先（SJF）调度算法短作业优先调度算法优先调度执行时间短的进程。

3、时间片轮转（RR）调度算法时间片轮转调度算法将 CPU 时间划分为固定大小的时间片，每个进程轮流获得一个时间片的 CPU 资源。

四、实验设计1、进程类的设计创建一个进程类，包含进程 ID、到达时间、服务时间、剩余服务时间等属性，以及用于更新剩余服务时间和判断进程是否完成的方法。

2、调度算法实现分别实现先来先服务、短作业优先和时间片轮转三种调度算法。

3、模拟流程（1）初始化进程列表。

（2）按照选定的调度算法进行进程调度。

（3）计算每个进程的等待时间、周转时间等性能指标。

五、实验步骤1、定义进程类｀｀｀pythonclass Process:def ＿_init__(self, pid, arrival_time, service_time)：selfpid ＝ pidselfarrival_time ＝ arrival_timeselfservice_time ＝ service_timeselfremaining_service_time ＝ service_time｀｀｀2、先来先服务调度算法实现｀｀｀pythondef fcfs_scheduling(process_list)：current_time ＝ 0total_waiting_time ＝ 0total_turnaround_time ＝ 0for process in process_list:if current_time ＜ processarrival_time:current_time ＝ processarrival_timewaiting_time ＝ current_time processarrival_timetotal_waiting_time ＋＝ waiting_timecurrent_time ＋＝ processservice_timeturnaround_time ＝ current_time processarrival_timetotal_turnaround_time ＋＝ turnaround_timeaverage_waiting_time ＝ total_waiting_time ／ len(process_list)average_turnaround_time ＝ total_turnaround_time ／ len(process_list) print(＂先来先服务调度算法的平均等待时间：＂，average_waiting_time)print(＂先来先服务调度算法的平均周转时间：＂，average_turnaround_time)｀｀｀3、短作业优先调度算法实现｀｀｀pythondef sjf_scheduling(process_list)：current_time ＝ 0total_waiting_time ＝ 0total_turnaround_time ＝ 0sorted_process_list ＝ sorted(process_list, key=lambda x: xservice_time) for process in sorted_process_list:if current_time ＜ processarrival_time:current_time ＝ processarrival_timewaiting_time ＝ current_time processarrival_timetotal_waiting_time ＋＝ waiting_timecurrent_time ＋＝ processservice_timeturnaround_time ＝ current_time processarrival_timetotal_turnaround_time ＋＝ turnaround_timeaverage_waiting_time ＝ total_waiting_time ／ len(process_list)average_turnaround_time ＝ total_turnaround_time ／ len(process_list) print(＂短作业优先调度算法的平均等待时间：＂，average_waiting_time)print(＂短作业优先调度算法的平均周转时间：＂，average_turnaround_time)｀｀｀4、时间片轮转调度算法实现｀｀｀pythondef rr_scheduling(process_list, time_slice)：current_time ＝ 0total_waiting_time ＝ 0total_turnaround_time ＝ 0ready_queue ＝while len(process_list) ＞ 0 or len(ready_queue) ＞ 0:for process in process_list:if processarrival_time ＜＝ current_time:ready_queueappend(process)process_listremove(process)if len(ready_queue) ＝＝ 0:current_time ＋＝ 1continueprocess ＝ ready_queuepop(0)if processremaining_service_time ＜＝ time_slice: waiting_time ＝ current_time processarrival_time total_waiting_time ＋＝ waiting_timecurrent_time ＋＝ processremaining_service_time turnaround_time ＝ current_time processarrival_time total_turnaround_time ＋＝ turnaround_time processremaining_service_time ＝ 0else:waiting_time ＝ current_time processarrival_time total_waiting_time ＋＝ waiting_timecurrent_time ＋＝ time_sliceprocessremaining_service_time ＝ time_sliceready_queueappend(process)average_waiting_time ＝ total_waiting_time ／ len(process_list)average_turnaround_time ＝ total_turnaround_time ／ len(process_list) print(＂时间片轮转调度算法（时间片大小为"， time_slice, ＂）的平均等待时间：＂， average_waiting_time)print(＂时间片轮转调度算法（时间片大小为"， time_slice, ＂）的平均周转时间：＂， average_turnaround_time)｀｀｀5、主函数｀｀｀pythonif ＿_name__ ＝＝＂＿_main__"：process_list ＝Process(1, 0, 5)，Process(2, 1, 3)，Process(3, 2, 8)，Process(4, 3, 6)print(＂先来先服务调度算法：＂）fcfs_scheduling(process_list)print(＂短作业优先调度算法：＂）sjf_scheduling(process_list)time_slice ＝ 2print(＂时间片轮转调度算法（时间片大小为"，time_slice, ＂）：＂）rr_scheduling(process_list, time_slice)｀｀｀六、实验结果与分析1、先来先服务调度算法平均等待时间为 575，平均周转时间为 1275。

实验报告：时间片轮转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;}四．调试分析在时间片大于所有进程的服务时间时，程序正常运行，当时间片小于某些进程的服务时间时，程序不能输出正确的运算结果。

实验报告二——进程调度算法的设计姓名: xxxx 学号: xxxxx班级: xxxx一、实习内容•实现短进程优先调度算法（SPF）•实现时间片轮转调度算法（RR）二、实习目的•通过对进程调度算法的设计, 深入理解进程调度的原理。

进程是程序在一个数据集合上运行的过程, 它是系统进行资源分配和调度的一个独立单位。

进程调度分配处理机, 是控制协调进程对CPU的竞争, 即按一定的调度算法从就绪队列中选中一个进程, 把CPU的使用权交给被选中的进程。

三、实习题目• 1.先来先服务（FCFS）调度算法原理: 每次调度是从就绪队列中, 选择一个最先进入就绪队列的进程, 把处理器分配给该进程, 使之得到执行。

该进程一旦占有了处理器, 它就一直运行下去, 直到该进程完成或因发生事件而阻塞, 才退出处理器。

将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列, 并按照先来先服务的方式进行调度处理, 是一种最普遍和最简单的方法。

它优先考虑在系统中等待时间最长的作业, 而不管要求运行时间的长短。

按照就绪进程进入就绪队列的先后次序进行调度, 简单易实现, 利于长进程, CPU繁忙型作业, 不利于短进程, 排队时间相对过长。

• 2.时间片轮转调度算法RR原理: 时间片轮转法主要用于进程调度。

采用此算法的系统, 其程序就绪队列往往按进程到达的时间来排序。

进程调度按一定时间片(q)轮番运行各个进程.进程按到达时间在就绪队列中排队, 调度程序每次把CPU分配给就绪队列首进程使用一个时间片, 运行完一个时间片释放CPU, 排到就绪队列末尾参加下一轮调度, CPU分配给就绪队列的首进程。

固定时间片轮转法:1 所有就绪进程按FCFS 规则排队。

2 处理机总是分配给就绪队列的队首进程。

3 如果运行的进程用完时间片, 则系统就把该进程送回就绪队列的队尾, 重新排队。

4 因等待某事件而阻塞的进程送到阻塞队列。

5 系统把被唤醒的进程送到就绪队列的队尾。

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类模拟了进程，对属性进⾏了封装。

电子科技大学实验报告学生姓名：满博学号：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算法功能已实现。

操作系统实验报告一、实验题目时间片轮转算法(RR算法)二、实验目的模拟实现时间片轮转调度算法。

理解时间轮转算法的处理机调度的基本思想。

三、实验要求1.初始化函数，输入各个进程的到达时间以及需要的运行的时间。

2.设置时间片大小，实现进程有等待到运行状态的转换。

3.进程运行时间结束后从进程列表中删除该进程。

四、实验内容在时间片调度算法的模拟实现中，时间片就是分配给进程运行的一段时间。

在轮转法中，系统将所有的可运行（即就绪）进程按先来先服务的原则，排成一个队列，每次调度时把CPU分配给队首进程，并令其执行一个时间片。

当某进程执行的时间片用完时，系统发出信号，通知调度程序，调度程序便据此信号来停止该进程的执行，并将刚运行的进程送到运行队列的末尾，等待下一次执行；然后，把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。

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

本实验设计一个有N个进程并发的进程调度程序，采用时间片轮转算法。

每一个进程用一个进程控制块PCB表示。

PCB包含信息有：进程名nme，进程号id，进程状态stte，进程所需运行时间need_time,进程运行时间run_time。

进程运行时间以时间片为单位进行计算。

（程序中以按任意键表示运行一次CPU时间片）每个进程的状态有就绪W，运行R，和完成（撤销进程）。

就绪的进程获得CPU后只能运行一个时间片，运行完运行时间run_time+1。

如果运行一个时间片后，进程的run_time等于need_time（即已经达到所需运行时间），则撤销该进程并提示，如果还未达到，则将其放到队尾，进入就绪状态等待下一次时间片分配。

每一次调度程序都打印一次运行情况，包括：运行的进程，就绪队列的进程，已经所有进程的PCB（不包括已经撤销的进程）。

五、实验结果：六、实验小结由于自己自编写代码方面与他人有一定的差距，因此在做实验的过程中我在网上搜了很多相关的资料，了解实现该算法的原理及各部分实现的代码，同时参考了几个别人写好的源代码，然后自己在理解的基础上不断的根据要求修改写程序，不过其中碰见的很多的问题。

进程调度算法实验报告进程调度算法实验报告一、引言进程调度算法是操作系统中非常重要的一部分，它决定了系统中各个进程的执行顺序和时间分配。

在本次实验中，我们将研究和比较几种常见的进程调度算法，包括先来先服务（FCFS）、最短作业优先（SJF）、轮转法（RR）和优先级调度算法。

二、实验目的本次实验的目的是通过模拟不同的进程调度算法，观察它们在不同情况下的表现，并比较它们的优缺点，以便更好地理解和应用这些算法。

三、实验过程1. 实验环境准备我们使用C语言编写了一个简单的进程调度模拟程序，该程序可以模拟不同的进程调度算法，并输出每个进程的执行顺序和等待时间等信息。

2. 实验步骤（1）先来先服务（FCFS）算法FCFS算法是最简单的一种进程调度算法，它按照进程的到达顺序来执行。

我们通过模拟多个进程的到达时间和执行时间，观察它们的执行顺序和等待时间。

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

我们通过模拟多个进程的执行时间，观察它们的执行顺序和等待时间。

（3）轮转法（RR）算法RR算法是一种时间片轮转的调度算法，每个进程被分配一个时间片，当时间片用完后，进程被挂起，等待下一次调度。

我们通过模拟不同的时间片大小，观察进程的执行顺序和等待时间。

（4）优先级调度算法优先级调度算法是根据进程的优先级来进行调度的，优先级高的进程优先执行。

我们通过模拟不同的进程优先级，观察进程的执行顺序和等待时间。

四、实验结果与分析1. 先来先服务（FCFS）算法当进程的执行时间相差不大时，FCFS算法的等待时间较长，因为后到达的进程需要等待前面的进程执行完毕。

但如果有一个进程的执行时间很长，其他进程的等待时间就会很短。

2. 最短作业优先（SJF）算法SJF算法能够保证最短执行时间的进程先执行，因此平均等待时间较短。

但如果有一个执行时间很长的进程到达，其他进程的等待时间就会变长。

实验二时间片轮转RR进程调度算法1、需求分析(1) 输入的形式和输入值的范围首先输入进程个数，然后再输入时间片的大小，然后按照到达时间的顺序输入每个进程的名字，然后输入进程到达的时间和服务时间，输入完成，程序显示算法的结果。

(2) 输出的形式程序的输出根据用户输入的时间片的大小到达时间以及服务时间，通过相应的计算输出其各自的完成时间，周转时间，带全周转时间以及平均值，程序输出这些结果。

3) 程序所能达到的功能1）输入进程个数n,时间片的大小t以及每个进程的名字和每个进程的到达时间T1, … ,T n和服务时间S1, … ,S n。

2）时间片轮转法RR调度进程运行，计算每个进程的周转时间和带权周转时间，并且计算所有进程的平均周转时间和带权平均周转时间。

3）输出：输出计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。

(4) 测试数据，包括正确的输入及其输出结果和含有错误的输入及其输出结果正确输入的结果错误输入的结果2、概要设计抽象数据类型的定义：int ArrivalTime[100];int ServiceTime[100];int PServiceTime[100];int FinishTime[100];int WholeTime[100];double WeightWholeTime[100];double AverageWT,AverageWWT;bool Finished[100];主程序的流程以及各程序模块之间的层次(调用)关系：3、详细设计该算法采用队列的方法实现。

先将第一个到达的进程入队，在规定的时间内将其运行，也有可能其服务时间小于实际时间片。

此时判断其他的程序有没有到达，到达就将其入队，没有到达则等待，然后判断此时在队头的进程是否完成执行，如果已经完成执行吗，则将其出对，若还没有完成，则将其调配到队尾，现在打头的进程依旧执行此方法判断，知道所有的进程都出队。

操作系统实验二进程调度摘要：进程调度是操作系统中重要的功能之一，可以决定进程的优先级和执行顺序。

本实验主要介绍了进程调度的概念、不同的调度算法以及如何实现进程调度。

一、概念介绍进程调度是操作系统中的一项重要功能，用于决定哪个进程能够在处理器上运行。

在操作系统中存在多个进程需要同时运行，而处理器资源有限，因此需要通过进程调度来合理地安排进程的执行顺序，提高系统的效率。

进程调度的目标是使系统的吞吐量最大化、响应时间最短、资源利用率最高等。

常见的调度策略包括先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转、优先级调度等。

二、调度算法介绍1.先来先服务（FCFS）先来先服务（FCFS）是最简单的调度算法，按照进程到达的顺序进行调度，先到达的进程先执行。

FCFS算法不考虑进程的优先级和执行时间，容易导致平均等待时间长。

2.最短作业优先（SJF）最短作业优先（SJF）调度算法按照进程所需的CPU时间进行排序，优先调度所需时间最短的进程。

SJF算法可以减少平均等待时间，但可能会导致长作业等待时间过长。

3.时间片轮转时间片轮转是一种抢占式调度策略，将处理器的使用权分割为若干个时间片，每个进程在一个时间片内运行，如果时间片用完仍未运行完，则将该进程放到队列的末尾，并让下一个进程运行。

时间片轮转算法保证了公平性和响应时间，但可能会导致上下文切换次数过多。

4.优先级调度优先级调度是根据进程的优先级进行调度，优先级高的进程先执行。

优先级可以根据进程类型、实时性等因素确定，不同的操作系统可能有不同的优先级范围和策略。

三、实验步骤1.定义进程结构：定义进程结构体，包含进程ID、进程状态、优先级、执行时间等信息。

2.初始化进程队列：将所有进程按照到达的先后顺序加入到进程队列中。

3.实现调度算法：根据不同的调度算法，实现相应的进程调度算法代码。

可以使用循环遍历进程队列，并根据不同的调度策略决定下一个要执行的进程。

4.执行进程调度：在每个时间片结束后，根据调度算法选取下一个要执行的进程，并更新进程的状态和执行时间。

xx大学操作系统实验报告姓名：学号：班级：实验日血厂——实验名称：时间片轮转RR进程调度算法实验二时间片轮转RR进程调度算法1.实验目的：通过这次实验,理解时间片轮转RR进程调度算法的运行原理,进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法.2.需求分析(1)输入的形式和输入值的范围；输入：进程个数n范围：0<n<=100时间片q依次输入(进程名进程到达时间进程效劳时间)输出的形式所有进程平均周转时间：所有进程平均带权周转时间：(3)程序所能到达的功能1)进程个数n,输入时间片大小q,每个进程的到达时间Ti,…n,和效劳时间S1,•••n,S2)要求时间片轮转法RR调度进程运行,计算每个进程的周转时间和带权周转时间,并且计算所有进程的平均周转时间和带权平均周转时间；3)输出：模拟整个调度过程,输出每个时刻的进程运行状态；4)输出：输出计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间.(4)测试数据,包括正确的输入及其输出结果和含有错误的输入及其输出结果.正确输入：错误输入：2、概要设计所有抽象数据类型的定义：staticintMaxNum=100intArrivalTime//到达时间intServiceTime//效劳时间intFinishedTime//结束时间intWholeTime//周转时间doubleWeightWholeTime//带权周转时间doubleAverageWT//平均周转时间doubleAverageWWT//平均带权周转时间主程序的流程:变量初始化接受用户输入的n,q,T1--..TnS1--.Sn;进行进程调度,计算进程的开始运行时间、结束时间、执行顺序、周转时间、带权周转时间；计算所有进程的平均周转时间、平均带权周转时间；根据格式输出调度结果.各程序模块之间的层次(调用)关系Main函数通过对Input函数进行调用,对函数的成员变量进行赋值,再通过RRAlgorithm函数求出题目要求的各个数据结果,最后通过display函数对结果进行格式输出.3、详细设计实现程序模块的具体算法.voidRRAlgorithm(){charprocessMoment[100];//存储每个时间片p对应的进程名称RRqueue.push(RRarray[0]);intprocessMomentPoint=0;intCurrentTime=0;inttempTime;〃声明此变量限制CurrentTime的累加时间,当前进程的效劳时间小于时间片q的时候,起到重要作用inti=1;//指向还未处理的进程的下标intfinalProcessNumber=0;〃执行RR算法后,进程的个数intprocessTime[50];//CurrentTime的初始化if(RRarray[0].ServiceTime>=q)CurrentTime=q;}else{CurrentTime=RRarray[0].ServiceTime;}while(!RRqueue.empty()){for(intj=i;j<n;j++)//使得满足进程的到达时间小于当前时间的进程都进入队列{if(RRarray[j].name!=NULL&&CurrentTime>=RRarray[j].ArrivalTime){RRqueue.push(RRarray[j]);i++;}}if(RRqueue.front().ServiceTime<q){tempTime=RRqueue.front().ServiceTime;}else{tempTime=q;}RRqueue.front().ServiceTime-=q;//进程每执行一次,就将其效劳时间-q//将队首进程的名称放入数组中processMoment[processMomentPoint]=RRqueue.front().name;processMomentPoint++;processTime[finalProcessNumber]=tempTime;finalProcessNumber++;if(RRqueue.front().ServiceTime<=0)//把执行完的进程退出队列{//RRqueue.front().FinishedTime=CurrentTime;RRqueue.pop();//如果进程的效劳时间小于等于,即该进程已经服务完了,将其退栈}else{//将队首移到队尾RRqueue.push(RRqueue.front());RRqueue.pop();}CurrentTime+=tempTime;//进程输出处理每个时间段对应的执行的进程cout<<"各进程的执行时刻信息："<<endl;cout<<""<<"0时刻-->"<<setw(2)<<processTime[0]<<时亥1J";processTime[finalProcessNumber]=0;inttime=processTime[0];intcount=0;for(i=0;i<finalProcessNumber;i++){count=0;cout<<setw(3)<<processMoment[i]<<setw(3)<<endl;while(RRarray[count].name!=processMoment[i]&&count<n){count++;}RRarray[count].FinishedTime=time;if(i<finalProcessNumber-1){cout<<setw(3)<<time<<"时亥1J"<<"-->"<<setw(2)<<time+ processTim e[i+1]<<‘时亥1J"<<setw(3);time+=processTime[i+1];}}cout<<endl;//周转时间、带权周转时间、平均周转时间、带权平均周转时间的计算//1.周转时间=完成时间-到达时间//2.带权周转时间=周转时间/效劳时间for(i=0;i<n;i++){RRarray[i].WholeTime=RRarray[i].FinishedTime-RRarray[i].ArrivalTime;RRarray[i].WeightWholeTime=(double)RRarray[i].WholeTime/RRarray[i].ServiceTime;}doublex=0,y=0;for(i=0;i<n;i++){x+=RRarray[i].WholeTime;y+=RRarray[i].WeightWholeTime;}AverageWT=x/n;AverageWWT=y/n;}4、调试分析(1)调试过程中遇到的问题以及解决方法,设计与实现的回忆讨论和分析在算法设计时,由于一开始不知道如何将位于队首的进程,在执行完后如何移至队尾进行循环,所以思考了很久,后来想到将队首进程进行重新压入队列从而解决了此问题.(2)算法的性能分析每个进程被分配一个时间段,即该进程允许运行的时间.如果在时间片结束时进程还在运行,那么CPU 将被剥夺并分配给另一个进程.如果进程在时间片结束前阻塞或结束,那么CPU 当即进行切换.调度程序所要做的就是维护一张就绪进程列表,当进程用完它的时间片后,它被移到队列的末尾.(3)经验体会通过本次实验,深入理解了时间片轮转RR 进程调度算法的思想,培养了自己的动手水平,通过实践加深了记忆.5、用户使用说明程序的使用说明,列出每一步的操作步骤charname;intArrivalTime;intServiceTime;intFinishedTime;intWholeTime;doubleWeightWholeTime;}RR;staticqueue<RR>RRqueue;〃声明一个队列staticdoubleAverageWT=0,AverageWWT=0;staticintq;//时间片 7、附录营汗牌的懈睛/侬辉硒|整典秘 #include<iostream>#include<queue>#include<iomanip>#include<fstream>#de fineMaxNum100usingnamespacestd;运行队首进程typedefstruct{ 进程运彳r 时间-时间片时间时间和预计效劳时间运行完成,将进程从队列中取出staticintn;//进程个数staticRRRRarray[MaxNum];〃进程结构voidInput(){//文件读取模式ifstreaminData;inData.open("./data4.txt");//data.txt 表示q=4的RR 调度算法//data2.txt 表示q=1的RR 调度算法inData>>n;inData>>q;for(inti=0;i<n;i++){inData>>RRarray[i].name;}for(i=0;i<n;i++){inData>>RRarray[i].ArrivalTime;}for(i=0;i<n;i++){inData>>RRarray[i].ServiceTime;}//用户输入模式****************************************************************〞 <endl;cout<<"请输入进程个数n:";cin>>n;cout<<"请输入时间片q:";cin>>q;cout<<"请按到达时间的顺序依次输入进程名："<<endl;for(i=0;i<n;i++){cin>>RRarray[i].name;}cout<<"请从小到大输入进程到达时间："<<endl;for(i=0;i<n;i++){cin>>RRarray[i].ArrivalTime;}cout<<〞请按到达时间的顺序依次输入进程效劳时间："<<endl; for(i=0;i<n;i++){cin>>RRarray[i].ServiceTime;}****************************************************************〞 <endl;//输出用户所输入的信息cout<<"Theinformationofprocessesisthefollowing:"<<endl; cout<<"cout<<"cout<<setw(10)<<"进程名"<<""；cout<<setw(10)<<‘到达时间"<<""；cout<<setw(10)<<"效劳时间"<<""<<endl;for(i=0;i<n;i++){cout<<setw(10)<<RRarray[i].name<<"";cout<<setw(10)<<RRarray[i].ArrivalTime<<"";cout<<setw(10)<<RRarray[i].ServiceTime<<""<<endl;}****************************************************************〞cout<<"<endl;}voidRRAlgorithm(){charprocessMoment[100];//存储每个时间片p对应的进程名称RRqueue.push(RRarray[0]);intprocessMomentPoint=0;intCurrentTime=0;inttempTime;〃声明此变量限制CurrentTime的累加时间,当前进程的效劳时间小于时间片q的时候,起到重要作用inti=1;//指向还未处理的进程的下标intfinalProcessNumber=0;//执行RR算法后,进程的个数intprocessTime[50];//CurrentTime的初始化if(RRarray[0].ServiceTime>=q){CurrentTime=q;}else{CurrentTime=RRarray[0].ServiceTime;}while(!RRqueue.empty()){for(intj=i;j<n;j++)//使得满足进程的到达时间小于当前时间的进程都进入队列{if(RRarray[j].name!=NULL&&CurrentTime>=RRarray[j].ArrivalTime){ RRqueue.push(RRarray[j]);i++;}}if(RRqueue.front().ServiceTime<q){tempTime=RRqueue.front().ServiceTime;else{tempTime=q;}RRqueue.front().ServiceTime-=q;//进程每执行一次,就将其效劳时间-q//将队首进程的名称放入数组中processMoment[processMomentPoint]=RRqueue.front().name;processMomentPoint++;processTime[finalProcessNumber]=tempTime;finalProcessNumber++;if(RRqueue.front().ServiceTime<=0)//把执行完的进程退出队列{ //RRqueue.front().FinishedTime=CurrentTime;RRqueue.pop();//如果进程的效劳时间小于等于,即该进程已经效劳完了,将其退栈}else{//将队首移到队尾RRqueue.push(RRqueue.front());RRqueue.pop();}CurrentTime+=tempTime;}//进程输出处理每个时间段对应的执行的进程cout<<"各进程的执行时刻信息："<<endl;cout<<""<<"0时刻-->"<<setw(2)<<processTime[0]<<时亥1J";processTime[finalProcessNumber]=0;inttime=processTime[0];intcount=0;for(i=0;i<finalProcessNumber;i++){count=0;cout<<setw(3)<<processMoment[i]<<setw(3)<<endl;while(RRarray[count].name!=processMoment[i]&&count<n){count++;}RRarray[count].FinishedTime=time;if(i<finalProcessNumber-1){cout<<setw(3)<<time<<"时刻"<<"-->"<<setw(2)<<time+processTime[i+1]<<‘时亥1J"<<setw(3);time+=processTime[i+1];}}cout<<endl;//周转时间、带权周转时间、平均周转时间、带权平均周转时间的计算//1.周转时间=完成时间-到达时间//2.带权周转时间=周转时间/效劳时间for(i=0;i<n;i++){RRarray[i].WholeTime=RRarray[i].FinishedTime-RRarray[i].ArrivalTime;RRarray[i].WeightWholeTime=(double)RRarray[i].WholeTime/RRarray[i].ServiceTime;}doublex=0,y=0;for(i=0;i<n;i++){x+=RRarray[i].WholeTime;y+=RRarray[i].WeightWholeTime;}AverageWT=x/n;AverageWWT=y/n;}cout<<" <<endl;******************************************************〞voiddisplay()cout<<"RR 调度算法执行后：进程相关信息如下："<<endl;cout<<setw(10)<<〞进程名(ID)"<<"";cout<<setw(10)<<‘到达时间"<<""；cout<<setw(10)<<"效劳时间"<<""；cout<<setw(10)<<'完成时间"<<""；cout<<setw(10)<<"周转时间"<<"";cout<<setw(10)<<,带权周"$时间〞<<endl;for(inti=0;i<n;i++){cout<<setw(10)<<RRarray[i].name<<,,;cout<<setw(10)<<RRarray[i].ArrivalTime<<,,cout<<setw(10)<<RRarray[i].ServiceTime<<,,;cout<<setw(10)<<RRarray[i].FinishedTime<<,,cout<<setw(10)<<RRarray[i].WholeTime<<,,;cout<<setw(10)<<RRarray[i].WeightWholeTime<<,,<<endl;;}coutvv 〞所有进程的平均周转时间="vvAverageWTvvendl;cout<<〞所有进程的平均带权周转时间="vvAverageWWTvvendl; }intmain(){Input();RRAlgorithm();display();return0; cout<<, <<endl;******************************************************〞。