时间片轮转调度算法资料
操作系统实验二报告-时间片轮转进程调度算法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算法进行进程调度, 计算进程的完成时间、周转时间和带权周转时间;➢计算所有进程的平均周转时间和平均带权周转时间;➢按格式输出调度结果。
时间片轮转调度算法例题详解

时间片轮转调度算法例题详解操作系统是计算机系统中的一个重要组成部分,它负责管理计算机系统的各种资源,协调各种应用程序的运行,保证计算机系统的高效稳定运行。
操作系统中的进程调度是其中的一个重要内容,它决定了进程在CPU上的运行顺序,直接影响到计算机系统的性能。
本文将详细介绍时间片轮转调度算法,并通过例题进行详解。
一、时间片轮转调度算法时间片轮转调度算法是一种基于时间片的进程调度算法,它将CPU时间片分配给各个正在运行的进程,每个进程在一个时间片内运行一定的时间,然后被挂起,等待下一次调度。
如果进程在一个时间片内没有完成运行,那么它将被挂起,等待下一次调度。
这种调度算法适用于多道程序并发执行的情况,可以避免进程长时间占用CPU,保证进程的公平性和响应性。
时间片轮转调度算法的基本思想是将所有就绪进程按照先来先服务的原则排队,每个进程在一个时间片内运行一定的时间,然后被挂起,等待下一次调度。
时间片的大小可以根据系统的负载情况进行调整,一般情况下,时间片的大小为10ms~100ms之间。
当一个进程在一个时间片内运行完成,它将被移到队列的末尾,等待下一次调度。
如果进程在一个时间片内没有完成运行,那么它将被挂起,等待下一次调度。
这样,所有进程都有机会获得CPU时间,避免了某个进程长时间占用CPU的情况。
时间片轮转调度算法的优点是简单易懂,易于实现,可以保证进程的公平性和响应性。
缺点是时间片的大小对系统的性能有较大影响,时间片过小会导致进程切换频繁,影响系统性能;时间片过大会导致进程响应时间增加,影响用户体验。
二、时间片轮转调度算法例题下面通过一个例题来详细介绍时间片轮转调度算法的实现过程。
题目描述:有3个进程P1、P2、P3,它们的运行时间分别为24ms、3ms、3ms,它们的到达时间分别为0ms、0ms、0ms。
时间片大小为4ms。
请计算它们的平均等待时间和平均周转时间。
解题思路:首先,按照到达时间的先后顺序将进程排队。
时间片轮转调度算法例题详解

时间片轮转调度算法例题详解在计算机操作系统中,调度算法是非常重要的一部分。
调度算法的作用是决定哪个进程可以获得 CPU 的使用权。
其中,时间片轮转调度算法是一种常见的调度算法,它可以保证每个进程都能够获得一定的 CPU 时间,从而避免了某个进程长时间占用 CPU 的情况。
本文将对时间片轮转调度算法进行详细的介绍,并通过实例来说明如何使用该算法进行进程调度。
一、时间片轮转调度算法的原理时间片轮转调度算法是一种抢占式的调度算法,它将 CPU 的使用时间划分为若干个时间片,每个进程在一个时间片内可以占用CPU 的时间是固定的。
当一个进程占用 CPU 的时间超过了一个时间片,系统会将该进程挂起,并将 CPU 分配给下一个进程。
时间片轮转调度算法的优点在于可以保证公平性,每个进程都能够获得一定的 CPU 时间,从而避免了某个进程长时间占用 CPU 的情况。
另外,该算法的实现比较简单,适用于多任务环境下的进程调度。
二、时间片轮转调度算法的实现时间片轮转调度算法的实现需要使用一个队列来保存所有等待CPU 时间的进程。
每个进程在队列中占据一个时间片的位置,当轮到该进程时,系统会将该进程从队列头部取出,并将其放到队列尾部。
如果一个进程占用 CPU 的时间超过了一个时间片,系统会将该进程挂起,并将其放到队列尾部。
下面是时间片轮转调度算法的具体实现步骤:1. 将所有等待 CPU 时间的进程放入一个队列中。
2. 设置一个时间片的长度,例如 10 毫秒。
3. 从队列头部取出一个进程,并将其放到 CPU 中执行。
4. 如果该进程在一个时间片内没有执行完毕,将其挂起,并将其放到队列尾部。
5. 从队列头部取出下一个进程,并将其放到 CPU 中执行。
6. 重复步骤 4 和步骤 5,直到所有进程都执行完毕。
三、时间片轮转调度算法的实例下面通过一个实例来说明如何使用时间片轮转调度算法进行进程调度。
假设有三个进程 P1、P2、P3,它们需要使用 CPU 的时间如下表所示:| 进程 | 到达时间 | 需要 CPU 时间 ||------|----------|---------------|| P1 | 0 | 20 || P2 | 0 | 25 || P3 | 0 | 10 |假设时间片的长度为 5 毫秒,现在需要使用时间片轮转调度算法对这三个进程进行调度。
时间片轮转调度算法实现

时间片轮转调度算法实现
时间片轮转调度算法(Round Robin Scheduling Algorithm)是一种常用的进程调度算法,其特点是将系统中的所有进程按照一定的时间片大小进行轮流调度执行,从而保证每个进程都能够获得一定的CPU时间,同时避免了某个进程长时间占用CPU的情况。
时间片轮转调度算法的基本原理是将所有就绪进程按照先后顺序排成一个队列,然后按照固定的时间片大小为每个进程分配一定的CPU时间,并在时间片用完后将进程从队列头部移到队列尾部,等待下一次调度。
这样,每个进程都能够得到一定的CPU时间,同时也保证了系统的公平性和响应性。
在实际运用中,时间片大小的选择对于系统的性能和响应速度有着重要的影响。
如果时间片过短,会导致进程过于频繁地进行上下文切换,从而降低系统的效率;如果时间片过长,会导致某些进程长时间占用CPU资源,影响其他进程的运行。
因此,在进行时间片大小的选择时,需要考虑系统的硬件配置、进程的性质、调度算法的实现等多方面因素。
通常情况下,时间片大小的选择应该根据实际情况进行调整,以保证系统的性能和响应速度。
除了时间片大小的选择之外,时间片轮转调度算法还有其它一些优化技巧,例如优先级调度、多级反馈队列调度等。
这些技巧能够进
一步提高系统的性能和响应速度,同时也能够更好地适应不同性质的进程。
时间片轮转调度算法是一种简单而有效的进程调度算法,在实际运用中有着广泛的应用。
通过合理地选择时间片大小、实现优化技巧等手段,能够更好地提高系统的性能和响应速度,为用户提供更加优质的服务。
调度算法之时间片轮转算法

调度算法之时间⽚轮转算法⼀.轮转法的基本原理:根据先来先服务的原则,将需要执⾏的所有进程按照到达时间的⼤⼩排成⼀个升序的序列,每次都给⼀个进程同样⼤⼩的时间⽚,在这个时间⽚内如果进程执⾏结束了,那么把进程从进程队列中删去,如果进程没有结束,那么把该进程停⽌然后改为等待状态,放到进程队列的尾部,直到所有的进程都已执⾏完毕⼆.进程的切换时间⽚够⽤:意思就是在该时间⽚内,进程可以运⾏⾄结束,进程运⾏结束之后,将进程从进程队列中删除,然后启动新的时间⽚时间⽚不够⽤:意思是在该时间⽚内,进程只能完成它的⼀部分任务,在时间⽚⽤完之后,将进程的状态改为等待状态,将进程放到进程队列的尾部,等待cpu的调⽤三.关于时间⽚⼤⼩的选择时间⽚过⼩,则进程频繁切换,会造成cpu资源的浪费时间⽚过⼤,则轮转调度算法就退化成了先来先服务算法c实现:#include<stdio.h>#include<string.h>#include<stdlib.h>#define TAKEIN "takein"//对应的进程状态#define WAIT "wait"#define RUN "run"#define FINISH "finish"#define PNUMBER 5//进程个数#define TRUE 1#define FALSE 0typedef struct pcb{char processName[20];//进程名称int arriveTime;//进程到达时间int startTime;//进程开始时间int endTime;//进程结束时间int runTime;//进程运⾏时间⼤⼩int turnOverTime;//周转时间int userweightTurnOverTime;//带权周转时间char provessStatus[10];//进程状态int runTimeed; //进程已经运⾏的时间} pcb;pcb pcbs[PNUMBER];//进程数组int currentTime=0;//时间int processIndex=0;//进程的编号int cpuTime=2;//时间⽚int size=PNUMBER;//进程数组中的有效值void createPcbs()//进程初始化函数{freopen("input.txt","r",stdin);//以只读操作读⽂件printf("进程名\t到达时间\t运⾏时间\n");int index;for(index=0; index<PNUMBER; index++)//遍历所有进程,给进程赋初值{scanf("%s",pcbs[index].processName);scanf("%d",&pcbs[index].arriveTime);scanf("%d",&pcbs[index].runTime);pcbs[index].endTime=0;pcbs[index].startTime=0;pcbs[index].turnOverTime=0;pcbs[index].userweightTurnOverTime=0;strcpy( pcbs[index].provessStatus,TAKEIN);printf("%s \t%d \t%d\n", pcbs[index].processName, pcbs[index].arriveTime, pcbs[index].runTime);}printf("\n***********************************************\n");}void movePcbs(int pindex){int index=0;pcb temp=pcbs[pindex];//需要移动的进程for(index=pindex;index<size-1;index++){pcbs[index]=pcbs[index+1];//后⾯的进程全部前移⼀位}pcbs[size-1]=temp;//⽬标进程移到数组尾部}//享受过cpu服务的进程移到进程数组的尾部,采⽤队列实现void printfPcbsInfo()//打印所有进程的所有信息{int index=0;printf("当前时间为:%d时各进程的信息.....\n\n",currentTime);printf("进程名\t到达时间\t运⾏时间\t开始时间\t结束时间\t周转时间\t带权周转时间\t状态\n");for(index=0; index<PNUMBER; index++){printf("%s\t%8d\t%8d\t%8d\t%8d\t%8d\t%8d\t%4s\n",pcbs[index].processName,pcbs[index].arriveTime,pcbs[index].runTime,pcbs[index].startTime, pcbs[index].endTime,pcbs[index].turnOverTime,pcbs[index].userweightTurnOverTime,pcbs[index].provessStatus);}}void sortPcbs()//按到达时间的升序排序{int minIndex=0,minValue=0,i,j;for(i=0; i<PNUMBER; i++){minIndex=i;minValue=pcbs[i].arriveTime;for(j=i; j<PNUMBER; j++){if(pcbs[j].arriveTime<minValue){minValue=pcbs[j].arriveTime;//保存最⼩的minIndex=j;}}pcb temp=pcbs[minIndex];//交换pcbs[minIndex]=pcbs[i];pcbs[i]=temp;}}int selNextProcess()//选择下⼀个进程,要求,最近的等待进程{int result=-1;int index=0;for(index=0;index<size;index++){if(strcmp(pcbs[index].provessStatus,WAIT)==0){return index;}}return result;}void removeFromPcbs(int pindex)//删除完成任务的进程{movePcbs(pindex);size--;//数组逻辑长度缩⼩,达到移除效果}int isHasProcessArrive()//检查在某⼀个时间点有没有进程到达{int result=-1;int index=0;for(index=0; index<PNUMBER; index++){if(pcbs[index].arriveTime==currentTime)//某个进程的到达时间等于当前时间{result=index;strcpy(pcbs[index].provessStatus,WAIT);//改变进程状态}}return result;}int proIsEnd(int pindex)//判断⼀个进程是否完成{if(pcbs[pindex].runTime==pcbs[pindex].runTimeed){currentTime++;//当前时间⾛到isHasProcessArrive();//判断是否有新到达进程strcpy(pcbs[pindex].provessStatus,FINISH);//进程相关信息的改变pcbs[pindex].turnOverTime=pcbs[pindex].endTime-pcbs[pindex].arriveTime;pcbs[pindex].userweightTurnOverTime=pcbs[pindex].turnOverTime*1.0/pcbs[pindex].runTime; removeFromPcbs(pindex);//移⾛完成的进程processIndex++;//准备下⼀个进程printfPcbsInfo();//打印此时所有进程的信息return TRUE;}return FALSE;}void runProcess(int pindex){int index=0;int end=FALSE;pcbs[pindex].startTime=currentTime;//进程开始运⾏时间为当前时间strcpy(pcbs[pindex].provessStatus,RUN);//进程状态改为运⾏态pcbs[pindex].runTimeed++;//进程已经运⾏时间加⼀printfPcbsInfo();if(proIsEnd(pindex)==TRUE)//检查在当前时间⽚下进程是否已经结束{currentTime--;return ;}if(cpuTime-1>=1)//时间⽚没有⽤完{for(index=0;index<cpuTime-1;index++){currentTime++;isHasProcessArrive();pcbs[index].runTimeed++;printfPcbsInfo();if(proIsEnd(pindex)==TRUE){pindex=size;end=TRUE;}}}if(end==FALSE)//如果在当前时间⽚下⾯进程没有结束{currentTime++;strcpy(pcbs[pindex].provessStatus,WAIT);movePcbs(pindex);printfPcbsInfo();}currentTime--;}void startProcess(){int firstArriveTime=pcbs[0].arriveTime;int nextIndex=0;while(1){currentTime++;isHasProcessArrive();//检查当前时间有没有进程到达if(currentTime<firstArriveTime){printfPcbsInfo();}else if(currentTime==firstArriveTime){runProcess(0);//执⾏进程}else{nextIndex=selNextProcess();if(nextIndex!=-1){runProcess(nextIndex);}else{printfPcbsInfo();}}if(processIndex==PNUMBER)break;}}int main(){createPcbs();sortPcbs();startProcess();return0;}输⼊⽂件:运⾏截图:结果分析:运⾏结果符合预期,在时间⽚内能完成任务的进程在完成任务后会被移出进程队列,在时间⽚内不能完成任务的进程在⽤完时间⽚的时间后会被移到进程队列的尾部不⾜错误之处欢迎拍砖指教!。
高响应比优先调度和时间片轮转rr进程调度算法

高响应比优先调度和时间片轮转rr进程调度算法高响应比优先调度和时间片轮转(RR)进程调度算法引言:在操作系统中,进程调度是一项重要且复杂的任务。
为了提高系统的性能和响应速度,研究人员和工程师开发了许多不同的调度算法。
本文将重点介绍高响应比优先调度(high response ratio priority scheduling)和时间片轮转(round-robin, RR)进程调度算法。
这两种算法都在实际应用中得到了广泛的运用,下面我将对其原理进行详细阐述,并比较它们的优缺点。
一、高响应比优先调度算法高响应比优先调度算法是一种根据进程的等待时间和执行时间来确定优先级的策略。
该算法认为,等待时间越长的进程应该被优先执行,以提高整体系统的响应速度。
具体而言,高响应比=(等待时间+执行时间)/执行时间。
等待时间是指进程在就绪队列中等待调度的时间,而执行时间则是进程实际执行的时间。
高响应比优先调度算法的主要步骤如下:2. 计算响应比:对于每个进程,根据上述公式计算其响应比,并赋予一个优先级。
3. 选择优先级最高的进程:从就绪队列中选择响应比最高的进程,并将其调度到CPU中执行。
4. 更新进程状态:执行完一个时间片后,更新进程的等待时间和执行时间。
5. 重复步骤3和4,直到所有进程都执行完毕。
高响应比优先调度算法的优点在于能够充分利用CPU资源,提高系统的响应速度。
然而,该算法也存在一些缺点。
首先,计算每个进程的响应比需要消耗大量的计算资源。
其次,长时间等待的进程会获得较高的优先级,可能导致一些短进程长时间得不到执行。
因此,在实际应用中需要权衡考虑。
二、时间片轮转调度算法时间片轮转调度算法是一种公平的调度策略,它将CPU的执行时间划分为固定长度的时间片,并将每个进程分配一个时间片来执行。
当一个时间片耗尽后,进程将被重新放入就绪队列中,等待下一次调度。
时间片轮转调度算法的主要步骤如下:2. 选择当前时间片内的进程:从就绪队列中选择一个进程,并将其调度到CPU中执行。
优先级加时间片轮转进程调度算法_概述及解释说明

优先级加时间片轮转进程调度算法概述及解释说明1. 引言1.1 概述本文旨在介绍优先级加时间片轮转进程调度算法。
进程调度是操作系统中的重要组成部分,它决定了多个进程之间的执行顺序和时间配比。
优先级调度算法和时间片轮转调度算法都是常用的进程调度算法,在不同场景下各具优缺点。
而结合这两种算法进行设计与实现,则能充分发挥它们的优势,提高系统的性能和效率。
1.2 文章结构本文将按照以下结构进行介绍:首先概述文章内容,明确文章重点和目标;然后详细讲解优先级调度算法,包括其定义、原理和实现方式;接着介绍时间片轮转调度算法,包括其定义、原理以及运行机制;随后探讨选择何种调度策略的问题;最后以设计思路与实现示例为基础,对结合优先级与时间片轮转调度算法进行分析,并进行性能评估和对比研究。
1.3 目的本文旨在深入探讨优先级加时间片轮转进程调度算法,阐明其背后的原理与机制,并通过实例演示说明如何设计与实现该算法。
此外,本文还将对该调度算法的优缺点进行分析,并提出进一步研究的方向和展望。
通过本文的阐述,读者能够全面了解并掌握优先级加时间片轮转进程调度算法的实现与应用。
2. 优先级调度算法:2.1 定义与原理:优先级调度算法是一种基于进程优先级的调度方法。
每个进程被赋予一个优先级,优先级越高的进程被认为是更重要的任务,应该在其他进程之前得到处理器资源。
该算法的原理是根据进程的优先级来确定调度顺序。
当有多个就绪状态的进程等待执行时,调度程序会选择具有最高优先级的进程执行。
如果两个或多个进程具有相同的优先级,则采用其他策略(如轮转或抢占)来选择将要运行的进程。
2.2 实现方式:实现这种调度算法可以采用不同的方法。
一种常见的方式是为每个进程分配一个固定的静态优先级,其值通常在范围内确定(比如0到255),其中较大的数字表示较高的优先级。
另一种方式是动态地根据某些因素为进程分配优先级,如当前执行时间、等待时间、紧迫性等。
在操作系统中,可以使用一个队列来存储就绪状态下各个进程,并按照它们的优先级进行排序。
操作系统实验报告时间片轮转调度算法

操作系统实验报告时间片轮转调度算法“网络协议分析”实验4实验名称:用Ethereal研究DNS和HTTP协议实验目的:通过对捕获分组的分析和研究,加深对DNS协议和HTTP协议的工作原理和实现过程的理解。
实验环境:连网PC机,Ethereal网络协议分析软件实验步骤:1.安装Ethereal网络协议分析器。
2.打开Ethereal软件菜单中的Help->Contents,可学习Ethereal的使用方法。
3.开始捕获分组之前,清空客户端Web浏览器的高速缓存和DNS的高速缓存(命令为:ipconfig /flushdns)。
(想一想,为什么?)4.在Capture->Option里选择网卡类型;取消捕获分组的“混杂模式”;设置捕获过滤器为:“host 本机IP”,这样Ethereal就会只捕获从本机发出的和发往本机的分组。
5.点击Start启动协议分析器,用Ethereal捕获从本机发出和发往本机的分组。
6.在Web浏览器中输入URL(如.cn, 等,网页较简单)。
网页显示出来后,过一会儿停止捕获。
将跟踪文件保存在一个文件中。
实验结果分析:1.在跟踪列表框中找出请求网页时发出的DNS查询报文和回答报文,找出发起TCP连接的三次握手报文,找出HTTP请求报文和响应报文。
2.在协议框中找出各层协议,观察各层协议,并对照教材中DNS查询/回答报文结构和HTTP请求/响应报文结构对这些应用层报文进行分析,找出报文中各字段相应的内容,解释其含义和用途。
3.你的主机所用的DNS服务器的IP地址是多少?你的浏览器与DNS服务器之间使用传输层的什么协议进行通信?202.196.0.1DNS请求报文和应答报文的ID号一样吗?是什么?一样,0xc4a6你所请求网站的规范名是什么?mail.DNS服务器对你的域名解析请求在应答中给出了几个可用的IP地址?都是什么?2个,202.196.0.16,202.196.0.17和DNS服务器通信时,你的客户机使用的端口号是多少?DNS服务器使用的端口号是多少?64384,53你所请求Web服务器的IP地址是什么?其域名有几个层次(参看教材127页)?202.196.0.16 4个如果请求一个存在/不存在的网页,Web服务器分别会应答什么? ??等等。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
while(head!=NULL) //当队首不为空时,把P给队首
{
r=p=head;
while(p!=NULL) //把执行时间给队首
{
t=head;
p->shengyutime=p->shengyutime-num; //P的剩余时间=剩余时间-时间片
p->state="运行"; //状态变成运行态
{
t=q;
q=q->next;
}
if(q==head) //而当Q是队首时,则下一个队首变成P,以便每个进程都能够得到时间片
{
p->next=head;
head=p;
}
else if(t==rear) //当执行时间片到达队尾时(执行完时),返回给队首P
{
rear->next=p;
p->next=NULL;
三、实验代码
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedefstruct PCB2
{
char name[10];//进程名
int runtime;//要求运行时间
intfrist;//定义优先数
char zhuangtai; //定义状态,R为就绪,F为完成
{
inቤተ መጻሕፍቲ ባይዱa,i;
structshijian *head, *rear,*p,*q,*t;//定义队首、队尾、P是队尾指针、Q是队首指针和执行时间
head=rear=NULL;//初始化队首和队尾为空
printf("请输入进程数目:");
scanf("%d",&a);
for(i=0;i<a;i++)
{
{
r=p;
p->state="就绪";
p=p->next;
}
}
}
}
void main()
{
int N;
int number;
char Tishikuang;//提示框
do{
printf("★*********★********★*******★******★********★*********★************★\n");
显示函数:在进程调度前、调度中和调度后进行显示。
排序函数:对就绪状态的进程按照进入就绪队列的时间排序,新到达的进行应优先于刚刚执行过的进程进入就绪队列的队尾。
调度函数:每次从就绪队列队首调度优一个进程执行,状态变化。并在执行一个时间片后化,服务时间变化,状态变化。当服务时间为0时,状态变为F。
删除函数:撤销状态为F的进行。
p=(structshijian*)malloc(sizeof(structshijian)); //初始化一个空间给进程进入
printf("输入第%d个进程的名字、到达时间、服务时间:\n",i+1);
scanf("%s%d%d",&p->name,&p->daodatime,&p->fuwutime);
{
if(p==head)
{
head=p->next;
free(p);
p=head;
}
else //否则返回执行,把队尾的下一个指针变成P的下一个指针,队尾的位置移动到队首
{
r->next=p->next;
p=r->next;
r=p;
}
}
else //否则把队首的位置给队尾,把队首的状态显示为“就绪”状态
p->shengyutime=p->fuwutime;
p->state="就绪";
if(rear==NULL) //当输入结束时,把P的数据放到队首,以便执行下一步
{
head=p;
p->next=NULL;
rear=p;
}
else //否则执行时间就为空,队首变成Q
{
t=NULL;
q=head;
while(q&&q->daodatime<p->daodatime)//当Q和Q的到达时间小于P的到达时间时,把执行时间给Q
};
structshijian {//定义时间片的结构体
char name; //定义进程名
intdaodatime;//到达时间
intfuwutime; //服务时间
intshengyutime;//剩余时间
char *state;//所处状态
structshijian *next;
};
structshijian *time()
rear=p;
}
else //否则给队首P占用执行时间,P执行完后到Q
{
t->next=p;
p->next=q;
}
}
}
return head;//返回队首
}
void output(structshijian *head)//定义输出函数
{
structshijian *p,*t,*r;
intnum;
printf("请输入时间片:");
4、时间片大小可以不为1,但至少实现时间片大小为1的RR调度。
二、实验内容:
模拟实现时间片轮转调度算法,具体如下:
设置进程体:进程名,进程的到达时间,服务时间,,进程状态(W——等待,R——运行,F——完成),进程间的链接指针
进程初始化:由用户输入进程名、服务时间进行初始化,同时,初始化进程的状态为W。
{
printf("%2c%8d%8d%14d%10s\n",t->name,t->daodatime,t->fuwutime,t->shengyutime,t->state);
t=t->next;
}
getchar(); //按住回车键观看
if(p->shengyutime==0)//当队首的剩余时间为0时,先把队首改成P的下一个,然后释放内存,删除队首节点
《操作系统》课程实验报告
实验名称:时间片轮转调度算法
班级:****************
学号:*************
姓名:**************
指导老师:***************
成绩:
一、实验目的:
1、测试数据可以随即输入或从文件中读入。
2、必须要考虑到进程的到达时间
3、最终能够计算每一个进程的周转时间的带权周转时间。
if(p->shengyutime<0) //当P运行完,即剩余时间小于0时,仍然把它当做0处理
p->shengyutime=0;
printf("\n************程序开始运行*****************\n");
printf("进程到达时间服务时间剩余时间当前状态\n");
while(t!=NULL) //时间不为空时,输出当前进程的信息,并把时间片交给下一个进程