实验一___处理器调度(设计一个按时间片轮转法实现处理器调度的程序)
实验一处理器调度实验报告

处理器调度一、实验内容选择一个调度算法,实现处理器调度。
二、实验目的在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。
当就绪状态进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。
本实验模拟在单处理器情况下处理器调度,帮助学生加深了解处理器调度的工作。
三、实验题目设计一个按优先数调度算法实现处理器调度的程序提示:(1)假定系统有五个进程,每一个进程用一个进程控制块PCB来代表。
进程控制块的格式为:其中,进程名----作为进程的标识,假设五个进程的进程名分别是R, P2, P3,P4,R。
指针—按优先数的大小把五个进程连成队列,用指针指出下一个进程的进程控制块首地址,最后一个进程中的指针为“ 0”。
要求运行时间-- 假设进程需要运行的单位时间数。
优先数-赋予进程的优先数,调度时总是选取优先数大的进程先执行。
状态-可假设有两种状态,“就绪”状态和“结束“状态,五个进程的初始状态都为“就绪“状态,用“ R”表示,当一个进程运行结束后,它的状态变为“结束”,用“ E”表示。
(2)在每次运行你所设计的处理器调度程序之前,为每个进程任意确定它的“优先数”和“要求运行时间”。
(3)为了调度方便,把五个进程按给定的优先数从大到小连成队列,用一单元指出队首进程,用指针指出队列的连接情况。
例:队首标志(4)处理器调度总是选队首进程运行。
采用动态改变优先数的办法,进程每运行一次优先数就减“ 1”。
由于本实验是模拟处理器调度,所以,对被选中的进程并不实际的启动运行,而是执行:优先数- 1 要求运行时间-1来模拟进程的一次运行提醒注意的是:在实际的系统中,当一个进程被选中运行时,必须恢复进程的现场,它占有处理器运行,直到出现等待事件或运行结束。
在这里省去了这些工作。
(5)进程运行一次后,若要求运行时间工0,则再将它加入队列(按优先数大小插入,且置队首标志);若要求运行时间=0,则把它的状态修改为“结束”(),且退出队列。
设计一个按优先数调度算法实现处理器调度的程序

设计一个按优先数调度算法实现处理器调度的程序处理器调度是操作系统中重要的任务之一,负责决定在多个可执行任务之间如何分配处理器时间。
在处理器调度中,按优先数调度算法是一种常见的策略。
本文将介绍如何设计一个按优先数调度算法实现处理器调度的程序。
一、定义任务在实现处理器调度之前,首先需要定义可执行的任务。
一个任务可以由多个属性来描述,包括优先级、到达时间、执行时间等。
在按优先数调度算法中,每个任务都有一个优先级,优先级越高表示任务的重要性越高。
同时,每个任务还有一个到达时间,即任务进入调度器的时间点。
最后,每个任务还有一个执行时间,表示任务完成所需要的时间。
二、设计数据结构为了表示任务,我们可以使用一个Task类来封装任务的属性,例如:```class Taskint priority; // 优先级int arrivalTime; // 到达时间int executionTime; // 执行时间};```此外,为了管理所有待调度的任务,需要使用一个队列来存储任务。
我们可以使用优先队列(Priority Queue)来实现这个队列,其中任务按照优先级的顺序排列。
当一个任务到达时,将其插入到优先队列中;当处理器空闲时,从优先队列中选择优先级最高的任务进行调度。
三、实现调度算法接下来,需要实现按优先数调度算法。
按照该算法的步骤,当一个任务到达时,将其插入到优先队列中。
当处理器空闲时,从队列中取出优先级最高的任务,并执行该任务。
如果任务未完成,则将其重新插入队列中。
如果所有任务都已完成,则调度任务结束。
以下是一个示例的按优先数调度算法实现:```PriorityQueue<Task> taskQueue; // 优先队列,按优先级排序任务void schedule(int currentTime)if (taskQueue.isEmpty()System.out.println("Processor is idle.");return;}Task currentTask = taskQueue.poll(; // 取出优先级最高的任务int remainingTime = currentTask.executionTime - (currentTime - currentTask.arrivalTime);if (remainingTime > 0)currentTask.executionTime = remainingTime;taskQueue.add(currentTask); // 将未完成的任务重新插入队列中} else}```四、模拟调度过程最后,我们可以编写一个简单的模拟函数来模拟调度器的执行过程:```void simulatint currentTime = 0; // 当前时间while (!taskQueue.isEmpty()while (!taskQueue.isEmpty( && taskQueue.peek(.arrivalTime <= currentTime)Task newTask = taskQueue.poll(;System.out.println("New task with priority " +newTask.priority + " arrived at " + currentTime + ".");taskQueue.add(newTask); // 插入新到达的任务}schedule(currentTime);currentTime++;}```在模拟函数中,我们不断地增加当前时间,直到所有任务都已完成。
设计一个按优先数调度算法实现处理器调度的进程

设计一个按优先数调度算法实现处理器调度的进程
一.处理器调度的简介
处理器调度是指在若干作业并发处理时,对处理器分配工作的动态过程。
它是操作系统中的一种重要技术,其主要功能是控制并发作业的执行,使他们得到公平的分配,正确的完成执行,以达到有效利用处理机资源,
提高系统的工作效率。
处理器调度技术包括:处理机调度算法、处理机调
度技术等。
处理机调度算法就是基于计算机系统的工作机制,根据不同的作业在
处理机上的执行情况,系统在不同的阶段,根据量的不同,采用不同的算法,按优先级、分时等原则进行处理机调度,使作业在不同的阶段得到公
平的分配,以达到有效利用处理机资源,提高系统工作效率的目的。
按优先数调度算法( Priority Scheduling Algorithm )是指根据作
业的优先级先后来分配处理机资源,使作业能够按照优先级依次被处理,
使得系统性能有所提高。
1.处理器调度的算法流程
按优先数调度算法的处理器调度的过程,如下:
首先,从队列中取出一个作业,检查是否具有最高优先级,如果是,
则将其分配给处理机,否则,该作业放回队列,继续下一步判断;
其次,在没有作业可以处理时,处理机将停止运转。
(实验2)按时间片轮转法实现处理器调度的模拟设计与实现

实验2 处理器调度一、实验内容选择一个调度算法,实现处理器调度。
二、实验目的在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。
当就绪进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。
本实验模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。
三、实验题目按时间片轮转法实现处理器调度的模拟设计与实现四、源代码#include<iostream>#include<string>using namespace std; //-----------------------struct _proc {char name[32];struct _proc *next;int run_time;int alloc_time;int state;//就绪为};_proc *root;//向就绪队列中插入进程,按照降序void Insert(_proc* pr) {if(root->next==NULL){root=pr;pr->next=pr;return;}pr->next=root->next;//插入root->next=pr;root=pr;}//创建进程_proc Creat(char name[],int run_time,int alloc_time) { _proc pr;strcpy(,name);pr.run_time=run_time;pr.alloc_time=alloc_time;pr.state=0;pr.next=NULL;return pr;}//删除就绪队列中对首进程void Delete() {if(root->next==root){root=NULL;return;}root->next=root->next->next;}//输出进程号,模拟进程执行void OutPut() {cout<<root->next->name<<endl;//输出,模拟进程执行++root->next->alloc_time;//修改进程}void Solve() {//根结点root=new _proc;root->state=0;//state记录就绪队列中的进程个数root->next=NULL;//空循环链表,指向自身//创建几个进程,并插入就绪队列_proc pr1=Creat("Q1",2,1);Insert(&pr1);_proc pr2=Creat("Q2",3,0);Insert(&pr2);_proc pr3=Creat("Q3",1,0);Insert(&pr3);_proc pr4=Creat("Q4",2,0);Insert(&pr4);_proc pr5=Creat("Q5",4,0);Insert(&pr5);cout<<"调度序列:"<<endl;while(root!=NULL)//一直循环遍历{OutPut();//执行root指向的进程//执行完毕即:run_time==alloc_time,从队列中删除该进程if(root->next->alloc_time==root->next->run_time)//执行完毕{Delete();//从就绪队列中,删除该进程continue;}root=root->next;//root指针后移,执行下一个进程做准备}}int main() {Solve();getchar();getchar();return 0;}五、实验结果。
实验一 处理机调度实验报告

实验一处理机调度实验报告一、实验目的处理机调度是操作系统中的一个重要组成部分,其目的是合理地分配处理机资源,以提高系统的性能和效率。
本次实验的主要目的是通过模拟处理机调度算法,深入理解不同调度算法的工作原理和性能特点,并能够对它们进行比较和分析。
二、实验环境本次实验使用了以下软件和工具:1、操作系统:Windows 102、编程语言:Python3、开发环境:PyCharm三、实验内容1、先来先服务(FCFS)调度算法先来先服务调度算法按照作业或进程到达的先后顺序进行调度。
即先到达的作业或进程先得到处理机的服务。
2、短作业优先(SJF)调度算法短作业优先调度算法优先调度运行时间短的作业或进程。
在实现过程中,需要对作业或进程的运行时间进行预测或已知。
3、高响应比优先(HRRN)调度算法高响应比优先调度算法综合考虑作业或进程的等待时间和运行时间。
响应比的计算公式为:响应比=(等待时间+要求服务时间)/要求服务时间。
4、时间片轮转(RR)调度算法时间片轮转调度算法将处理机的时间分成固定大小的时间片,每个作业或进程在一个时间片内运行,当时间片用完后,切换到下一个作业或进程。
四、实验步骤1、设计数据结构为了表示作业或进程,设计了一个包含作业或进程 ID、到达时间、运行时间和等待时间等属性的数据结构。
2、实现调度算法分别实现了上述四种调度算法。
在实现过程中,根据算法的特点进行相应的处理和计算。
3、模拟调度过程创建一组作业或进程,并按照不同的调度算法进行调度。
在调度过程中,更新作业或进程的状态和相关时间参数。
4、计算性能指标计算了平均周转时间和平均带权周转时间等性能指标,用于评估不同调度算法的性能。
五、实验结果与分析1、先来先服务(FCFS)调度算法平均周转时间:通过计算所有作业或进程的周转时间之和除以作业或进程的数量,得到平均周转时间。
在 FCFS 算法中,由于按照到达顺序进行调度,可能会导致长作业或进程长时间占用处理机,从而使平均周转时间较长。
处理器调度实验报告

一、实验目的1. 理解处理器调度的基本概念和原理;2. 掌握常用的处理器调度算法,如先来先服务(FCFS)、短作业优先(SJF)、优先级调度等;3. 分析不同调度算法的性能指标,如平均周转时间、平均带权周转时间等;4. 通过实验,提高实际操作和编程能力。
二、实验原理处理器调度是操作系统中的一个重要组成部分,其主要任务是合理分配处理器资源,使系统中的多个进程高效、有序地运行。
常见的处理器调度算法有以下几种:1. 先来先服务(FCFS):按照进程到达就绪队列的顺序进行调度,先到先服务;2. 短作业优先(SJF):优先选择运行时间最短的进程执行;3. 优先级调度:根据进程的优先级进行调度,优先级高的进程先执行;4. 时间片轮转(RR):将每个进程分配一个时间片,按照时间片轮转的方式调度进程。
三、实验内容1. 实验环境:Windows操作系统,Python编程语言;2. 实验工具:Python编程环境,如PyCharm、Spyder等;3. 实验步骤:(1)设计一个进程类,包含进程名、到达时间、运行时间、优先级等属性;(2)编写调度算法,实现FCFS、SJF、优先级调度和时间片轮转算法;(3)模拟进程执行过程,记录各个进程的执行时间、等待时间、周转时间等性能指标;(4)分析不同调度算法的性能,比较其优劣。
四、实验结果与分析1. FCFS调度算法实验结果:平均周转时间为20,平均带权周转时间为1.25。
分析:FCFS调度算法简单易实现,但可能导致进程响应时间长,不利于实时性要求高的系统。
2. SJF调度算法实验结果:平均周转时间为16,平均带权周转时间为1.2。
分析:SJF调度算法可以缩短平均周转时间,提高系统性能,但可能使长作业长时间等待,影响公平性。
3. 优先级调度算法实验结果:平均周转时间为18,平均带权周转时间为1.3。
分析:优先级调度算法可以根据进程的优先级进行调度,提高系统响应速度,但可能导致低优先级进程长时间等待。
操作系统实验一选择一个调度算法,实现处理器调度。

操作系统实验一报告一.实验内容选择一个调度算法,实现处理器调度。
二.实验目的在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。
当就绪状态进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。
本实验模拟在单处理器情况下处理器调度,帮助学生加深了解处理器调度的工作。
三.实验要求设计一个按优先数调度算法实现处理器调度的进程。
YNY上面的过程只给出了 那个寻找以及排序的大体过程,具体的过程太多画不下。
寻找优先级最高节点是否最高优先级优先数减一 运行时间减一继续寻找节点 运行时间是否为0删除节点 按优先级重新排序四.实验程序这个实验的程序使用的visual studio 2008 的c++ win控制台写的,所以可能老师的电脑里面。
我把程序结果贴在后面,还有第二题我也做了,但只要求写一个,那么。
// 操作系统实验.cpp : 定义控制台应用程序的入口点。
//#include"stdafx.h"#include<iostream>#include<string>using namespace std;static int num=0;class proc{private: string procname;proc * next;int time;int priority;char state;public:proc(){proc*next=new proc();}proc(string pr,proc * ne,int ti,int pri,char st):procname(pr),next(ne),time(ti),priority(pri),state(st){}~proc(){}void setnext(proc * n){next=n;}void setprocname(string s){procname=s;}void settime(int t){time=t;}void setpriority(int s){priority=s;}void setstate(char s){state=s;}proc * getnext(){return next;}string getprocname(){return procname;}int gettime(){return time;}int getpriority(){return priority;}char getstate(){return state;}};class dui{private:proc * first;public:dui(){first=new proc();}dui(proc*f){ first=f;}int getfirst_time(){return first->gettime();}void show(proc*p){cout<<"名字"<<"下个节点的名字"<<" "<<"时间"<<"优先级"<<"状态"<<endl;while(p){cout<<p->getprocname ()<<" "<<((p->getnext()!=NULL)?p->getnext ()->getprocname ():"NU")<<" "<<p->gettime ()<<" "<<p->getpriority()<<" "<<((p->gettime ()!=0)?p->getstate():'E')<<endl;p=p->getnext ();}cout<<"..............................................................."<<endl;}void process1(){proc*pp=first;show(first);while( first->getnext ()!=NULL){proc*pp_next=pp->getnext ();int a,b;a=pp->getpriority()-1;b=pp->gettime()-1;pp->setpriority(a);pp->settime(b);if(b==0){show(pp);pp =first=first->getnext ();continue;}int prio1,prio2;prio2=first->getnext ()->getpriority();prio1=pp->getpriority();if(prio1>=prio2){show(pp); }else{while(prio1<prio2){first=first->getnext ();if(first->getnext ()==NULL){first->setnext (pp);pp->setnext (NULL);break;}else prio2=first->getnext ()->getpriority(); }if(prio1>=prio2){pp->setnext (first->getnext ());first->setnext (pp);show(pp_next);}if(pp->getnext ()==NULL){show(pp_next); }pp=pp_next;first=pp;}}if(first->getnext ()==NULL)while(first->gettime()>0){int t=first->gettime()-1;first->settime(t);show(first);cout<<"五";}}};int main(){proc * A=new proc("p1",NULL,2,1,'R');proc * B=new proc("p2",NULL,3,5,'R');proc * C=new proc("p3",NULL,1,3,'R');proc * D=new proc("p4",NULL,2,4,'R');proc * E=new proc("p5",NULL,4,2,'R');B->setnext (D);D->setnext (C);C->setnext (E);E->setnext (A);dui aaa(B);//aaa.setfirst (B);aaa.process1 ();cin.get();return 0 ;}五.实验结果六.实验总结这个说来惭愧啊,因为自己的这个程序早就做好了,就是对进程啊什么的还不是很了解,因为自己不是学习认真的那一种,这个老师的那些问题把我给郁闷了好多天啊!悲剧!以后还是要好好学习,课后不能再玩得那么狠了!通过这个程序,我体会到了些程序前先把图给画出来是都么好的习惯啊!以后要多多用!还有我的电脑因为不知道什么病毒,c盘重还原了一下,原来在桌面的那个报告比这个更详细,这次因为不能上传加上自己没有保存就丢失了那个报告,临时写的这个希望老师不要怪我!!最后希望老师弄一下,最起码我们可以在机房里上传到ftp中!!!。
设计一个按优先数调度算法实现处理器调度的进程

实验报告2012 ~2013 学年第一学期课程操作系统原理实验名称设计一个按优先数调度算法实现处理器调度的进程小组成员阮广杰、陈智磊、高天翔、董云鹏专业班级10级计本三班指导教师屠菁2012 年11 月29号操作系统实验报告实验目的:在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。
当就绪状态进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。
本实验模拟在单处理器情况下处理器调度,设计一个按优先数调度算法实现处理器调度的进程,通过运行程序,能够清楚的表述优先数调度的过程,进一步掌握优先数调度算法的实现。
实验内容:设计一个按优先数调度算法实现处理器调度的进程。
实验步骤:概要设计:(1)假定系统有5个进程,每个进程用一个PCB来代表。
PCB的格式为:进程名、指针、要求运行时间、优先数、状态。
进程名——P1~P5。
指针——按优先数的大小把5个进程连成队列,用指针指出下一个进程PCB 的首地址。
要求运行时间——假设进程需要运行的单位时间数。
优先数——赋予进程的优先数,调度时总是选取优先数大的进程先执行。
状态——假设两种状态,就绪,用R表示,和结束,用E表示。
初始状态都为就绪状态。
(2) 每次运行之前,为每个进程任意确定它的“优先数”和“要求运行时间”。
(3) 处理器总是选队首进程运行。
采用动态改变优先数的办法,进程每运行1次,优先数减1,要求运行时间减1。
(4) 进程运行一次后,若要求运行时间不等于0,则将它加入队列,否则,将状态改为“结束”,退出队列。
(5) 若就绪队列为空,结束,否则,重复(3)。
详细设计:1、程序中使用的数据结构及符号说明:typedef struct PCB{char name[50];// 进程名以序号代替LPVOID lp;// 指向进程的长指针,模拟的,所以没用到。
int tm;// 需要运行的时间int prior;// 初始的优先数char state;// 状态struct PCB *next; // 指向下一个PCB块}PCB;3、源程序清单://Main.cpp// prior.cpp : Defines the entry point for the application.//#include "stdafx.h"#include "resource.h"#include "MainDlg.h"#include <COMMCTRL.H>int APIENTRY WinMain(HINSTANCE hInstance,//当前进程句柄HINSTANCE hPrevInstance,// 前次进程句柄LPSTR lpCmdLine,// 启动信息int nCmdShow)//{//Enable IPAddress、Calendar.etcInitCommonControls();//系统调用函数DialogBox(hInstance, MAKEINTRESOURCE(IDD_MAIN), NULL, Main_Proc);return 0;}//MainDlg.cpp#include "stdafx.h"#include <windows.h>#include <windowsx.h>#include "resource.h"#include "MainDlg.h"#include "cross.h"#include "time.h"int MAX_NUM;// 用户输入进程数char *pst1="------------------------------------------------------------------------------\r\n"; char *pst2="=======================================\r\n";typedef struct PCB{char name[50];// 进程名以序号代替LPVOID lp;// 指向进程的长指针,模拟的,所以没用到。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验一处理器调度一、实验内容选择一个调度算法,实现处理器调度。
二、实验目的在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。
当就绪进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。
本实习模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。
三、实验题目第二题:设计一个按时间片轮转法实现处理器调度的程序。
[提示]:(1)假定系统有五个进程,每一个进程用一个进程控制块PCB来代表。
进程控制块的格式为:其中,Q1,Q2,Q3,Q4,Q5。
指针——进程按顺序排成循环队列,用指针指出下一个进程的进程控制块的首地址最后一个进程的指针指出第一个进程的进程控制块首地址。
要求运行时间——假设进程需要运行的单位时间数。
已运行时间——假设进程已经运行的单位时间数,初始值为“0”。
状态——有两种状态,“就绪”和“结束”,初始状态都为“就绪”,用“R”表示。
当一个进程运行结束后,它的状态为“结束”,用“E”表示。
(2) 每次运行所设计的处理器调度程序前,为每个进程任意确定它的“要求运行时间”。
(3) 把五个进程按顺序排成循环队列,用指针指出队列连接情况。
另用一标志单元记录轮到运行的进程。
例如,当前轮到P2执行,则有:标志单元K1K2K3K4K5PCB1 PCB2 PCB3 PCB4 PCB5(4)处理器调度总是选择标志单元指示的进程运行。
由于本实习是模拟处理器调度的功能,所以,对被选中的进程并不实际的启动运行,而是执行:已运行时间+1来模拟进程的一次运行,表示进程已经运行过一个单位的时间。
请同学注意:在实际的系统中,当一个进程被选中运行时,必须置上该进程可以运行的时间片值,以及恢复进程的现场,让它占有处理器运行,直到出现等待事件或运行满一个时间片。
在这时省去了这些工作,仅用“已运行时间+1”来表示进程已经运行满一个时间片。
(5)进程运行一次后,应把该进程的进程控制块中的指针值送到标志单元,以指示下一个轮到运行的进程。
同时,应判断该进程的要求运行时间与已运行时间,若该进程的要求运行时间 已运行时间,则表示它尚未执行结束,应待到下一轮时再运行。
若该进程的要求运行时间=已运行时间,则表示它已经执行结束,应指导它的状态修改成“结束”(E)且退出队列。
此时,应把该进程的进程控制块中的指针值送到前面一个进程的指针位置。
(6)若“就绪”状态的进程队列不为空,则重复上面的(4)和(5)的步骤,直到所有的进程都成为“结束”状态。
(7)在所设计的程序中应有显示或打印语句,能显示或打印每次选中进程的进程名以及运行一次后进程队列的变化。
(8)为五个进程任意确定一组“要求运行时间”,启动所设计的处理器调度程序,显示或打印逐次被选中的进程名以及进程控制块的动态变化过程。
四. 所用数据结构及符号说明typedef struct PNode//PCB{struct PNode *next; //定义指向下一个节点的指针char name[10]; //定义进程名,并分配空间int All_time; //定义总运行时间int Runed_Time; //定义已运行时间char state; //定义进程状态Ready/End}*Proc; //指向该PCB的指针int ProcNum; //总进程数六.源代码:#include<iostream>#include<cstdlib>using namespace std;typedef struct PNode//PCB{struct PNode *next; //定义指向下一个节点的指针char name[10]; //定义进程名,并分配空间int All_time; //定义总运行时间int Runed_Time; //定义已运行时间char state; //定义进程状态Ready/End}*Proc; //指向该PCB的指针int ProcNum; //总进程数//初始化就绪队列void lnitPCB(Proc &H){cout << "请输入总进程个数:";cin >> ProcNum; //进程总个数int Num = ProcNum;H = (Proc)malloc(sizeof(PNode)); //建立头结点H->next = NULL;Proc p = H; //定义一个指针cout << "总进程个数为" << ProcNum << "个,请依次输入相应信息"<<endl;cout << endl;while (Num--){p = p->next = (Proc)malloc(sizeof(PNode));cout << "进程名,总运行时间,已运行时间:";cin >> p->name >> p->All_time >> p->Runed_Time;p->state = 'R';p->next = NULL;}p->next = H->next;}//输入运行中的进程信息void Displnfo(Proc H){Proc p = H->next;do{if (p->state != 'E') //如果该进程的状态不是End 的话{cout << "进程名:" << p->name << "\t总运行时间:" << p->All_time << "\t 已运行时间" << p->Runed_Time << "\t状态:" << p->state << endl;p = p->next;}else p = p->next;} while (p != H->next); //整个进程链条始终完整,只是状态位有差异}//时间片轮转法void SJP_Simulator(Proc &H){cout << endl << "-------------START-----------------\n";int flag = ProcNum; //记录剩余进程数int round = 0; //记录轮转数Proc p = H->next;while (p->All_time>p->Runed_Time){round++;cout << endl << "Round" << round << "--正在运行" << p->name << "进程" << endl;p->Runed_Time++; //更改正在运行的进程的已运行的时间Displnfo(H); //输出此时为就绪状态的进程的信息if (p->All_time == p->Runed_Time){//判断该进程是否结束p->state = 'E';flag--;cout << p->name << "进程已运行结束,进程被删除!\n";}p = p->next;while (flag && p->All_time == p->Runed_Time)p = p->next; //跳过先前已结束的进程}cout << endl << "-------------------END-----------------\n";}void main(){Proc H;lnitPCB(H); //数据初始化Displnfo(H); //输出此刻的进程状态SJP_Simulator(H);//时间片轮转法system("pause");}七、测试数据与实验结果八、结果分析与实验体会时间片轮转算法中,系统将所有的就绪程序按先来先服务的原则排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片(一个较小的时间单元)。
轮转法是一种剥夺式调度,当执行的时间片用完时,调度程序停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片,就这样一次又一次地执行,一次又一次地等待,直到该进程的任务完成。
时间片轮转调度算法特别适合于分时系统中使用。
该算法的难度和关键在于选择合理的时间片。
如果时间片过长,时间片轮转法就变成了先来先服务调度算法,如果时间片过小,则系统会花费大部分时间用于上下文切换。