时间片轮转调度算法实验分析报告
(08信管)进程时间片轮转调度算法--操作系统实验报告

(08信管)进程时间片轮转调度算法--操作系统实验报告操作系统实验报告—进程时间片轮转调度算法一、实验题目:进程时间片轮转调度算法二、实验原理:在多道程序系统中,一个作业被提交后必须经过处理机调度后,方能获得处理机执行。
对调度的处理又都可采用不同的调度方式和调度算法。
调度算法是指:根据系统的资源分配策略所规定的资源分配算法。
三、实验目的:1、加深对进程概念的理解,明确进程和程序的区别。
2、深入系统如何组织进程、创建进程。
3、进一步认识如何实现处理器调度。
4、通过对进程调度算法的设计,深入理解进程调度的原理。
5、加深对时间片轮转调度算法的理解。
四、实验要求:用C++语言编写程序完成单处理机的进程调度,要求采用时间片轮转调度算法。
实验具体要求包括:首先确定作业控制块的内容和组成方式;然后完成作业调度;最后编写主函数,并对所做工作进行测试。
五、语言环境:计算机基本配置要求:操作系统:WIN 98/2000/XP/2003 等Windows平台内存:256MB及以上主存64KB(Memory)(以KB为单位分配)开发语言:Visual C++ 6.0五、数据结构typedef struct jcb{char name[N];int prio;int round;int cputime;int needtime;int count;char state;struct node *next;}JCB六、参考源程序#include#include#include#includetypedef struct node{char name[10];int prio;int round;int cputime;int needtime;int count;char state;struct node *next;}PCB;PCB *finish,*ready,*tail,*run; //队列指针int N; //进程数void firstin(){run=ready; //就绪队列头指针赋值给运行头指针run->state='R'; //进程状态变为运行态]ready=ready->next; //就绪队列头指针后移到下一进程}//输出标题函数void prt1(char a){if(toupper(a)=='P') //优先级法cout<<" "<<endl;< p="">cout<<"进程名占用CPU时间到完成还要的时间轮转时间片状态"<<endl;< p="">}//进程PCB输出void prt2(char a,PCB *q){if(toupper(a)=='P') //优先级法的输出cout<name<<" "<cputime<<" "<needtime<<" "<<q->round<<" "<state<<endl;< p="">}//输出函数void prt(char algo){PCB *p;prt1(algo); //输出标题if(run!=NULL) //如果运行指针不空prt2(algo,run); //输出当前正在运行的PCB p=ready; //输出就绪队列PCBwhile(p!=NULL){prt2(algo,p);p=p->next;}p=finish; //输出完成队列的PCB while(p!=NULL){prt2(algo,p);p=p->next;}getchar(); //按住任意键继续}//时间片轮转的插入算法void insert(PCB *q){PCB *p1,*s,*r;s=q; //待插入的PCB指针p1=ready; //就绪队列头指针r=p1; //*r做pl的前驱指针while(p1!=NULL)if(p1->round<=s->round) {r=p1;p1=p1->next;}if(r!=p1){r->next=s;s->next=p1;}else{s->next=p1; //否则插入在就绪队列的头ready=s;}}//优先级创建初void create(char alg){PCB *p;int i,time;char na[10];ready=NULL;finish=NULL;run=NULL;cout<<"输入进程名及其需要运行的时间:"< {p=new PCB;cin>>na;cin>>time;strcpy(p->name,na);p->cputime=0;p->needtime=time;p->state='W';p->round=0;if(ready!=NULL)insert(p);else{p->next=ready;ready=p;}cout<<"输入进程名及其需要运行的时间:"<<=""> prt(alg);run=ready;ready=ready->next;run->state='R';}void timeslicecycle(char alg){while(run!=NULL){run->cputime=run->cputime+10;run->needtime=run->needtime-10;run->round=run->round+10;if(run->needtime<=0){run->next=finish;finish=run;run->state='F';run=NULL;if(ready!=NULL)firstin();}else{run->state='W';insert(run);firstin();}prt(alg);}}//主函数void main(){char algo='P'; //算法标记cout<<"输入进程的个数:";cin>>N; //输入进程数create(algo); //创建进程timeslicecycle(algo); //优先级法调度} //main()七、运行结果1、输入数据2、运行结果示例(1)数据输入完成后的初始状态,进程标识为x1的进程首先得到调度,运行10个时间单位。
时间片算法实验报告

时间片算法实验报告时间片调度算法是一种基于轮询的调度算法,在实验中它被应用于多道程序运行环境中,实现了多个程序之间的轮流执行。
本实验旨在通过实现一个基于时间片调度算法的简单操作系统,以及对其进行性能评估来深入理解该调度算法的工作原理和优缺点。
1. 实验所用材料与方法本实验使用C语言编程实现一个具有基本功能的操作系统。
在该系统中,定义了一个PCB(Process Control Block,进程控制块)结构体,用于保存进程的相关信息,如进程ID、优先级、状态等。
同时,系统中维护一个进程队列,用于存储所有申请CPU时间片的进程。
在时间片调度算法中,系统将时间划分为固定的时间片,当一个进程得到CPU 的时间片后,执行一段指定的CPU时间,然后被中断,以便让其他进程获得执行的机会。
在本实验中,假设每个时间片的长度为100ms。
2. 实验过程与结果在实验中,首先实现了一个简单的时间片调度算法的操作系统,并使用该操作系统执行了一系列的测试任务,利用日志记录了每个任务的执行时间和完成情况。
然后,对比了不同任务数量和优先级情况下的系统性能,并分析了结果。
通过实验结果可以看出,当任务数量较少时,时间片调度算法能够保证每个任务能够按照预期的时间片轮流执行,且每个任务完成时间较为均衡。
然而,当任务数量增多时,由于时间片的限制,每个任务能够获得的执行时间减少,导致任务完成时间延长,系统的响应时间也相应增加。
此外,实验还对比了不同优先级的任务在系统中的执行情况。
当任务的优先级较高时,系统会优先执行这些任务,从而保证任务的及时响应。
然而,如果某些优先级较低的任务长时间得不到执行,可能会导致任务的响应速度变慢,甚至影响整个系统的正常运行。
3. 实验总结与思考时间片调度算法是一种简单且公平的调度算法,它能够有效地提高多任务环境中任务的响应速度。
然而,该算法也存在一些不足之处。
首先,由于每个任务只能获得固定的执行时间片,当任务数量增多时,每个任务可获得的执行时间减少,从而导致任务的完成时间延长。
时间片轮转法完成进程调度(操作系统实验报告)剖析

时间片轮转法完成进程调度【实验目的】(1)加深对进程的理解(2)理解进程控制块的结构(3)理解进程运行的并发性(4)掌握时间片轮转法进程调度算法【实验内容】(1)建立进程控制块(2)设计三个链队列,分别表示运行队列、就绪队列和完成队列(3)用户输入进程标识符以及进程所需的时间,申请空间存放进程PCB信息。
(4)每一个时间片结束输出各进程的进程号,CPU时间(即已经占用的CPU时间),所需时间(即还需要的CPU时间),以及状态(即用W表示等待,R表示运行,F表示完成)【程序代码】#include "stdio.h"#include"stdlib.h"struct PCB{int pid; //进程标识符int rr; //已运行时间int time; //进程要求运行时间char sta; //进程的状态struct PCB *next; //链接指针};struct PCB pcb1,pcb2,pcb3,pcb4,pcb5,*tail,*head,*rp;init(){int i,time;pcb1.pid = 1;pcb2.pid = 2;pcb3.pid = 3;pcb4.pid = 4;pcb5.pid = 5;pcb1.rr =pcb2.rr =pcb3.rr =pcb4.rr =pcb5.rr = 0;pcb1.sta = pcb2.sta = pcb3.sta = pcb4.sta = pcb5.sta = 'w'; printf("请输入时间片p1需要运行的时间:");scanf("%d",&time);pcb1.time = time;printf("请输入时间片p2需要运行的时间:");scanf("%d",&time);pcb2.time = time;printf("请输入时间片p3需要运行的时间:");scanf("%d",&time);pcb3.time = time;printf("请输入时间片p4需要运行的时间:");scanf("%d",&time);pcb4.time = time;printf("请输入时间片p5需要运行的时间:");scanf("%d",&time);pcb5.time = time;pcb1.next=&pcb2;pcb2.next=&pcb3;pcb3.next=&pcb4;pcb4.next=&pcb5;pcb5.next=&pcb1;head = &pcb1;tail = &pcb5;}void printf1(){printf("+---------------|---------------|---------------|---------------+\n");printf("|\tpid\t|\trr\t|\ttime\t|\tSTA\t|\n");printf("|---------------|---------------|---------------|---------------|\n");}printf2(){printf("processes p%d running\n",head->pid);printf1();printf("|\t%d\t|\t%d\t|\t%d\t|\t%c\t|\n",head->pid,head->rr,head->time,head->sta);printf("|---------------|---------------|---------------|---------------|\n");rp=head;while(rp!=tail){rp=rp->next;printf("|\t%d\t|\t%d\t|\t%d\t|\t%c\t|\n",rp->pid,rp->rr,rp->time,rp->sta);printf("|---------------|---------------|---------------|---------------|\n");}}operation(){int flag=1;while (flag<=5){head->rr ++;if ((head->rr==head->time)||(head->time==0)){tail->sta='w';head->sta='f';printf2();head=head->next;tail->next=head;flag++;}else{tail->sta='w';head->sta='r';printf2();tail=head;head=head->next;}}}void main(){init(); //初始化printf("this is the begin state :\n"); printf2(); //显示初始状态operation(); //运行}【结果截图】。
实验五-时间片轮转调度分析

上海应用技术学院程序设计语言实验报告图1图2将本实验文件夹中的multi.exe文件添加到软盘镜像的根目录中。
如图3。
图5图7图8 按F5启动调试。
如图9。
图10BIT_TEST(PspReadyBitmap, PspCurrentThread->Priority) PspReadyThread(PspCurrentThread);图13 按F5启动调试。
如图14。
图14图16 (2)F7生成项目。
如图17。
图18古今名言敏而好学,不耻下问——孔子业精于勤,荒于嬉;行成于思,毁于随——韩愈兴于《诗》,立于礼,成于乐——孔子己所不欲,勿施于人——孔子读书破万卷,下笔如有神——杜甫读书有三到,谓心到,眼到,口到——朱熹立身以立学为先,立学以读书为本——欧阳修读万卷书,行万里路——刘彝黑发不知勤学早,白首方悔读书迟——颜真卿书卷多情似故人,晨昏忧乐每相亲——于谦书犹药也,善读之可以医愚——刘向莫等闲,白了少年头,空悲切——岳飞发奋识遍天下字,立志读尽人间书——苏轼鸟欲高飞先振翅,人求上进先读书——李苦禅立志宜思真品格,读书须尽苦功夫——阮元非淡泊无以明志,非宁静无以致远——诸葛亮熟读唐诗三百首,不会作诗也会吟——孙洙《唐诗三百首序》书到用时方恨少,事非经过不知难——陆游问渠那得清如许,为有源头活水来——朱熹旧书不厌百回读,熟读精思子自知——苏轼书痴者文必工,艺痴者技必良——蒲松龄声明访问者可将本资料提供的内容用于个人学习、研究或欣赏,以及其他非商业性或非盈利性用途,但同时应遵守著作权法及其他相关法律的规定,不得侵犯本文档及相关权利人的合法权利。
谢谢合作!。
时间片轮转调度算法实验

时间片轮转调度算法实验时间片轮转调度算法是一种广泛应用于计算机操作系统中的调度算法。
本文将介绍时间片轮转调度算法的基本原理、特点以及实验过程。
一、时间片轮转调度算法的基本原理时间片轮转调度算法是一种基于时间片的调度算法,它将CPU时间分配给多个进程,每个进程都被赋予一个时间片,当时间片用完后,该进程将被挂起,CPU时间将被分配给下一个进程。
被挂起的进程将被放入一个就绪队列中,等待下一轮时间片到来。
二、时间片轮转调度算法的特点1.公平性:时间片轮转调度算法可以保证每个进程都能够得到一定的CPU时间,从而保证了公平性。
2.响应时间快:时间片轮转调度算法可以保证进程的响应时间快,因为每个进程都会被分配一定的CPU时间。
3.适用性广:时间片轮转调度算法适用于多种场景,包括多用户、多任务、实时任务等。
4.实现简单:时间片轮转调度算法的实现比较简单,可以通过一个就绪队列和一个定时器来实现。
三、时间片轮转调度算法的实验过程1.实验环境:本次实验使用了Linux操作系统,编程语言为C++。
2.实验步骤:(1)创建进程:首先需要创建多个进程,并将它们放入就绪队列中。
(2)分配时间片:为了模拟时间片轮转调度算法,需要为每个进程分配一个时间片。
(3)执行进程:按照就绪队列中的顺序,依次执行每个进程,并在执行完一个时间片后,将进程放回就绪队列中。
(4)更新进程状态:根据进程的执行情况,更新进程的状态,包括运行中、就绪、阻塞等。
(5)输出结果:最后,输出每个进程的执行结果,包括进程的状态、执行时间等。
3.实验结果:经过实验,我们发现时间片轮转调度算法可以保证每个进程都能够得到一定的CPU时间,并且响应时间较快。
同时,我们也发现时间片的大小会对进程的执行时间和响应时间产生影响。
如果时间片过小,会导致进程频繁切换,从而降低CPU的利用率;如果时间片过大,会导致进程响应时间过长,影响用户体验。
四、总结时间片轮转调度算法是一种广泛应用于计算机操作系统中的调度算法,具有公平性、响应时间快、适用性广、实现简单等特点。
操作系统实验二报告-时间片轮转进程调度算法1

操作系统实验报告实验二时间片轮转进程调度算法学号:班级:姓名:【实验题目】: 时间片轮转进程调度算法【实验目的】通过这次实验, 加深对进程概念的理解, 进一步掌握进程状态的转变、进程调度的策略与对系统性能的评价方法。
【实验内容】问题描述:设计程序模拟进程的时间片轮转RR 调度过程。
假设有n 个进程分别在T1, … ,Tn 时刻到达系统, 它们需要的服务时间分别为S1, … ,Sn 。
分别利用不同的时间片大小q, 采用时间片轮转RR 进程调度算法进行调度, 计算每个进程的完成时间, 周转时间和带权周转时间, 并且统计n 个进程的平均周转时间和平均带权周转时间。
程序要求如下:1)进程个数n ;每个进程的到达时间T 1, … ,T n 和服务时间S 1, … ,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, … ,Tn, S1, … ,Sn;时间片大小q;➢按照时间片轮转RR算法进行进程调度, 计算进程的完成时间、周转时间和带权周转时间;➢计算所有进程的平均周转时间和平均带权周转时间;➢按格式输出调度结果。
实验二时间片轮转算法实验报告

实验二时间片轮转算法实验报告一、实验目的本次实验的主要目的是了解时间片轮转算法的工作原理,学习如何使用时间片轮转算法进行进程调度,并了解时间片大小对进程调度的影响。
二、实验原理时间片轮转算法是一种公平的进程调度算法,它采用循环队列的形式,将所有需要运行的进程按照到达时间排序,并将它们按照轮转的方式依次执行,每个进程在一个时间片内执行一定的时间(时间片大小),然后被暂停并放在队列的末尾等待下一次调度。
当一个进程的时间片用完后,它会被暂停并放在队列的最后,而在这个时间片内没有执行完的进程会被暂停并放到队列的开头,以便继续下一轮的运行。
这样一直循环下去,直到所有进程都运行完毕。
三、实验步骤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根据以上调度情况,我们可以计算出平均等待时间和平均周转时间。
时间片轮转调度算法实验

时间片轮转调度算法实验时间片轮转调度算法是一种基于时间片轮转的进程调度算法,它按照轮转的方式,将每个进程分配一个时间片,如果该进程在时间片结束前未完成其任务,则该进程将被挂起,然后下一个进程继续执行。
下面将从实验过程、结果分析和算法优缺点三个方面回答该问题。
实验过程:本次实验使用C语言编写程序,模拟了一个简单的时间片轮转调度算法。
实验环境为Windows 10操作系统,使用了Dev-C++ 5.11编译器。
实验流程如下:1.首先定义了一个进程的结构体,其中包括了进程的名称、进程需要执行的时间片以及已经执行的时间片。
2.定义一个队列来存储进程,为了方便起见,队列采用了循环存储结构。
3.在主函数中,首先输入需要执行的进程数和一个时间片长度,接着依次输入每个进程的名称和需要执行的时间。
程序会根据输入的信息初始化进程,并将进程加入队列。
4.最后,程序开始模拟调度器的调度过程。
每次从队列中取出一个进程,将其执行时间减去一个时间片。
如果执行时间为0,则代表该进程已经完成任务,将其移出队列。
如果执行时间大于0,则将该进程重新加入队列尾部,然后下一个进程开始执行。
结果分析:在进行实验的过程中,我们发现时间片轮转调度算法可以很好地实现多进程的调度。
通过不断地轮转时间片,每个进程都有机会被执行。
此外,该算法具有良好的响应时间和公平性,能够确保每个进程都能够在一定时间内执行一定的任务,从而提高了系统的利用率和效率。
算法优缺点:时间片轮转调度算法具有以下几个优点:1. 公平性:每个进程都能够在一定时间内获得相同的可执行时间。
2. 可控性:时间片长度可以根据需要自行改变。
3. 高效性:可以很好地支持多进程的调度,提高了系统的利用率和效率。
同时,该算法也存在一些缺点:1.时间片的长度可能对进程的执行效率产生影响,长度过长会导致进程轮转过于缓慢,降低了系统的响应速度,长度过短则会增加进程上下文切换的次数。
2. 由于算法本身的局限性,它可能无法解决一些与进程先后顺序等有关的问题,例如死锁或者资源争用等。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实现程序模块的具体算法。
void RRAlgorithm()
{
char processMoment[100]; //存储每个时间片p对应的进程名称
RRqueue.push(RRarray[0]);
int processMomentPoint = 0;
int CurrentTime=0;
int tempTime; //声明此变量控制CurrentTime的累加时间,当前进程的服务时间小于时间片q的时候,起到重要作用
if (RRqueue.front().ServiceTime <= 0) //把执行完的进程退出队列
{
//RRqueue.front().FinishedTime = CurrentTime;
RRqueue.pop(); //如果进程的服务时间小于等于,即该进程已经服务完了,将其退栈
}
else
{
//将队首移到队尾
processTime[finalProcessNumber]=0;
int time = processTime[0];
int count = 0;
for (i=0;i<finalProcessNumbcout<<setw(3)<<processMoment[i]<<setw(3)<<endl;
主程序的流程:
变量初始化
接受用户输入的n,q,T1…..Tn, S1….Sn;
进行进程调度,计算进程的开始运行时间、结束时间、执行顺序、周转时间、带权周转时间;
计算所有进程的平均周转时间、平均带权周转时间;
按照格式输出调度结果。
各程序模块之间的层次(调用)关系
Main函数通过对Input函数进行调用,对函数的成员变量进行赋值,再通过RRAlgorithm函数求出题目要求的各个数据结果,最后通过display函数对结果进行格式输出。
RRqueue.push(RRqueue.front());
RRqueue.pop();
}
CurrentTime += tempTime;
}
//进程输出处理每个时间段对应的执行的进程
cout<<"各进程的执行时刻信息:"<<endl;
cout<<" "<<"0时刻--> "<<setw(2)<<processTime[0]<<"时刻";
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]<<"时刻"<<setw(3);
xx大学操作系统实验报告
姓名:学号:班级:
实验日期:
实验名称:时间片轮转RR进程调度算法
实验二时间片轮转RR进程调度算法
1.实验目的:通过这次实验,理解时间片轮转RR进程调度算法的运行原理,进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。
2.需求分析
(1)输入的形式和输入值的范围;
输入:进程个数n范围:0<n<=100
//将队首进程的名称放入数组中
processMoment[processMomentPoint] = RRqueue.front().name;
processMomentPoint++;
processTime[finalProcessNumber] = tempTime;
finalProcessNumber++;
时间片q
依次输入(进程名
进程到达时间
进程服务时间)
(2)输出的形式
进程名
到达时间
服务时间
完成时间
周转时间
带权周转时间
所有进程平均周转时间:
所有进程平均带权周转时间:
(3)程序所能达到的功能
1)进程个数n,输入时间片大小q,每个进程的到达时间T1, … ,Tn和服务时间S1, … ,Sn。
2)要求时间片轮转法RR调度进程运行,计算每个进程的周转时间和带权周转时间,并且计算所有进程的平均周转时间和带权平均周转时间;
}
else
{
CurrentTime = RRarray[0].ServiceTime;
}
while(!RRqueue.empty())
{
for (int j=i;j<n;j++) //使得满足进程的到达时间小于当前时间的进程都进入队列
{
if (RRarray[j].name!=NULL && CurrentTime >= RRarray[j].ArrivalTime)
int ArrivalTime//到达时间
int ServiceTime//服务时间
int FinishedTime//结束时间
int WholeTime//周转时间
double WeightWholeTime//带权周转时间
double AverageWT//平均周转时间
double AverageWWT //平均带权周转时间
3)输出:模拟整个调度过程,输出每个时刻的进程运行状态;
4)输出:输出计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。
(4)测试数据,包括正确的输入及其输出结果和含有错误的输入及其输出结果。
正确输入:
错误输入:
2、概要设计
所有抽象数据类型的定义:
static int MaxNum=100
{
RRqueue.push(RRarray[j]);
i++;
}
}
if (RRqueue.front().ServiceTime<q)
{
tempTime = RRqueue.front().ServiceTime;
}
else
{
tempTime = q;
}
RRqueue.front().ServiceTime -= q; //进程每执行一次,就将其服务时间-q
int i=1; //指向还未处理的进程的下标
int finalProcessNumber = 0; //执行RR算法后,进程的个数
int processTime[50];
//CurrentTime的初始化
if (RRarray[0].ServiceTime>=q)
{
CurrentTime = q;