您的位置：360文档中心› 时间片轮转算法和优先级调度算法 C语言模拟实现 收藏精编版

时间片轮转算法和优先级调度算法 C语言模拟实现 收藏精编版

合集下载

时间片轮转调度算法(vc版)

时间片轮转调度算法(vc版)

时间片轮转调度算法设计目的:熟悉各种作业/进程调度算法的原理。

设计要求:用高级语言编写和调试多个实现不同的作业/进程调度算法的程序。

设计内容:基于时间片的轮转调度的模拟。

设计一个系统,提供一个界面,供用户输入等待调度的作业信息,显示调度的结果。

//实验名称:时间片轮转调度算法//实验日期:2008/07/16//实验者:qhu-hh//实验环境:Visual C++ 2008 ExPress Edition//编程语言:C语言//程序思想:先模拟建立进程就绪链表----置所有进程的到达时间Parrive_time均为0,依PCB链接顺序从第一个进程PCB开始,////////////////使Pid依次为1,2,3,4……;就绪链表中进程的数量,由常量MAXSIZE 控制; ////////////再模拟建立调度函数--------取表头PCB,修改进程执行时间,得到的新时间,即为剩余执行时间,当剩余时间小于或等于0////////////////时,将此进程的PCB取出,依完成的先后次序链到完成链表中,记录当前完成进程的完成时间Pend_time,////////////////同时修改就绪链表表头;////////////最后计算和打印里程调度信息-----计算出各进程周转时间及所有进程的平均周转时间。

#include"stdio.h"#include"malloc.h"#define TIMESLICE 2//时间片;#define MAXSIZE 4//就绪链中进程数量;typedef struct PCB//定义进程控制块的信息结构;{int Pid;//进程标识号;int Parrive_time;//进程到达时间;int Pend_time;//进程结束时间;int Pexe_time;//进程执行时间;struct PCB *next;//链向一下进程;}Node,*PNode;PNode PCurrent=NULL;//定义全局变量,指向当前进程的PCB;PNode PLast=NULL;//定义全局变量,指向上一进程PCB;PNode PHead=NULL;//定义全局变量,指向第一个进程的PCB;PNode PTail=NULL;//全局变量,指向就绪进程链的最后一个进程的PCB; int Exe_time[MAXSIZE];bool judge=0;//建立进程就绪链表int Create(){int i=1;if(PCurrent==NULL)//就绪链表为空时;{PCurrent=(PNode)malloc(sizeof(Node));PCurrent->Pid=i;i++;//标识新建进程;PCurrent->Parrive_time=0;//初始化;printf("输入执行用时:");scanf("%d",&(PCurrent->Pexe_time));//新进程执行用时; Exe_time[i-2]=PCurrent->Pexe_time;//进程执行用时备份; printf("\n");PCurrent->Pend_time=0;//初始化;PCurrent->next=NULL;//初始化;PHead=PTail=PCurrent;//改变链头、链尾指向;};do{PCurrent=(PNode)malloc(sizeof(Node));PCurrent->Pid=i;i++;//标识新进程;PCurrent->Parrive_time=0;//初始化printf("输入执行用时:");scanf("%d",&(PCurrent->Pexe_time));//新进程执行用时;Exe_time[i-2]=PCurrent->Pexe_time;//进程执行用时备份;printf("\n");PCurrent->Pend_time=0;//初始化;PCurrent->next=NULL;//初始化;PTail->next=PCurrent;//链到链尾PTail=PCurrent;//改变链尾if(i>MAXSIZE)judge=1;}while(judge==0);printf("%d,%d\n",PHead,PTail);return 0;}int Prin(PNode P)//检验就绪链表中各进程PCB储存信息;{printf("打印就绪链表:\n");while(P!=NULL)//就绪链空时,检验完;{printf("标识号:%d,执行时间:%d,到达时间:%d\n ",P->Pid,P->Pexe_time,P->Parrive_time);P=P->next;}printf("打印结束:\n");return 0;}//时间片轮转调度PNode Time_slice_dispatch(PNode PH,PNode PT){printf("I'm Time_slice_dispatch(1);\n");PNode P_Head=NULL;PNode P_Tail=NULL;////处理完成的进程组成的链表头结点和尾结点;//PCurrent=PLast=NULL;//PCurrent=PH;int Time_count=0;//计时器;printf("计时器初始值:%d\n",Time_count);//printf("%d",PH);while(PH!=NULL)//就绪进程链表未处理完时,继续处理; {Time_count+=TIMESLICE;//当前时间;printf("计时器值——————————————%d\n",Time_count); printf("进程 %d 要求执行时间:%d\n",PH->Pid,PH->Pexe_time);PH->Pexe_time-=TIMESLICE;//当前处理进程剩余时间;printf("进程 %d 剩余执行时间:%d\n",PH->Pid,PH->Pexe_time);if(PH->Pexe_time<=0)//当前目标进程执行完时的处理方式;{if(P_Head==NULL)//{P_Head=P_Tail=PH;//处于完成态的进程的链表的表头与表尾; P_Head->Pend_time=Time_count;//记录第一个结束的进程的结束时间;printf("first overti me:………………%d\n",Time_count); PH=PH->next;//改变就绪进程链表的表头;PT->next=NULL;P_Tail->next=NULL;//结束进程的表尾next的域置空;}else{P_Tail->next=PH;//链到结束进程的表尾;P_Tail=PH;P_Tail->Pend_time=Time_count;//记录结束时间;//P_Tail=PCurrent;//改变结束进程的表尾;PH=PH->next;//改变就绪进程链表的表头;//PCurrent=PCurrent->next;/*PLast->next=PCurrent->next;*/P_Tail->next=NULL;//结束进程的表尾next的域置空;}}else//当前目标进程未处理完时的处理方式;{PT->next=PH;//将当前未完成的进程链到就绪链表表尾;PT=PH;///////////////////////////////////////////////**** **********/////////////////////PLast=PCurrent;PH=PH->next;//PCurrent;//这两句是改变就绪进程链表的表头;PT->next=NULL;}}/*if(P_Head==NULL)printf("kkkkkkkkkkkkk");*/ int b;scanf("%c",&b);return P_Head;}int Print(PNode P_H){PCurrent=P_H;char c;double a=0;while(PCurrent!=NULL){printf("\n进程标识号:%d,执行时间:%d,结束时间%d,周转时间:%d",PCurrent->Pid,Exe_time[PCurrent->Pid-1],PCurrent->Pend_time,( PCurrent->Pend_time)-(PCurrent->Parrive_time));printf("\n");a+=(PCurrent->Pend_time)-(PCurrent->Parrive_time); PCurrent=PCurrent->next;}printf("平均周转时间:%f",a/MAXSIZE);scanf("%c",&c);printf("%c",c);return 0;}//////////////////////////////int main(){PNode head;Create();Prin(PHead);head=Time_slice_dispatch(PHead,PTail); Print(head);return 0;}。

进程调度算法(时间片轮转法+优先级)

进程调度算法(时间片轮转法+优先级)

进程调度算法时间片轮转法+优先级#include<stdio.h>#include<stdlib.h>#include<iostream.h>#define P_NUM 5//进程数#define P_TIME 50//时间片数//状态enum state{ready,//就绪execute,//执行block,//阻塞finish//结束};//PCB结构体struct pcb{char name[5];//进程名IDint priority;//优先级int cputime;//进程已占用时间片int alltime;//还需占用时间片state process;//进程状态pcb * next;//队列指针next，用来将多个进程控制块PCB链接为队列}PCB;pcb * get_process(){pcb *q;pcb *t;pcb *p;int i=0;cout<<"input ID and ALLTIME"<<endl;while (i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb));//申请cin>>q->name;cin>>q->alltime;//输入名字及时间q->cputime=0;//初始q->priority=P_TIME-q->alltime;//优先数越大，优先级越高q->process=ready;//就绪q->next=NULL;if (i==0){p=q;t=q;}else{t->next=q;t=q;}i++;}return p;}//输出过程void display(pcb *p){cout<<" ID"<<" "<<"CPUTIME"<<" "<<"ALLTIME"<<" "<<"PRIORITY"<<" "<<"STATE"<<endl;while(p){cout<<" "<<p->name<<" "<<p->cputime<<" "<<p->alltime<<" "<<p->priority<<" ";switch(p->process){case ready:cout<<"ready"<<endl;break;case execute:cout<<"execute"<<endl;break;case block:cout<<"block"<<endl;break;case finish:cout<<"finish"<<endl;break;}p=p->next;cout<<"\n";}}//状态的函数//结束int process_finish(pcb *q){int a=1;while(a&&q){a=a&&q->alltime==0;q=q->next;}return a;}//执行void cpuexe(pcb *q){pcb *t=q;int tp=0;while(q){if (q->process!=finish){q->process=ready;if(q->alltime==0){q->process=finish;}}if(tp<q->priority&&q->process!=finish){tp=q->priority;t=q;}q=q->next;}if(t->alltime!=0){t->priority-=3;//进程每运行一个时间片,优先数减3t->alltime--;t->process=execute;t->cputime++;}}//进程调度void process_way(){pcb * p;p=get_process();display(p);int cpu=0;while(!process_finish(p)){cpu++;cout<<"cputime:"<<cpu<<endl;cpuexe(p);display(p);}printf("All processes have finished"); }void main(){process_way();}结果：。

四种进程调度算法 先到先服务,优先级,短作业优先,时间片轮转

四种进程调度算法 先到先服务,优先级,短作业优先,时间片轮转

#include"stdio.h"#define N 50int n;int sj;struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻int yxj; //优先级int st2; //标志是否完成float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];void input(Gzuo a[]){printf("请输入进程个数：");scanf("%d",&n);for(int i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);a[i].st2 = a[i].st;printf("\n");}printf("\t请输入时间片大小(0<sjp):\t"); scanf("%d",&sj);}void sjp(Gzuo a[],int sj)//时间片轮转调度{int i,j,min,time;float sum1,sum2;bool flag=true;/*printf("\t请输入进程数(0<n<=50):\t"); scanf("%d",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);printf("\n\n");printf("\t请输入时间片大小(0<sjp):\t"); scanf("%d",&sjp);while(sjp<=0){printf("n\t请重新输入：");scanf("%d",&sjp);}/*struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻int st2; //标志是否完成float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);a[i].st2 = a[i].st;printf("\n");}*/for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].st2;a[i].st2=a[i+1].st2;a[i+1].st2=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}time = a[0].dt;//printf("赋值后TIME值为：%d\n",time);min = 0;while(min<n){flag=true;for(i=0;i<n;i++){if(a[i].st2>0&&a[i].dt<=time)flag=false;}for(i=0;i<n;i++){if(a[i].st2 > 0 ){if(a[i].dt<=time){//printf("当前a[%d].st2值为：%d\n",i,a[i].st2);a[i].st2 = a[i].st2 - sj;//printf("运算后当前a[%d].st2值为：%d\n",i,a[i].st2); //printf("当前TIME值为：%d\n",time);time = time + sj;//printf("增加之后TIME值为：%d\n",time);if(a[i].st2<=0){a[i].wct = time + a[i].st2;a[i].zt=(float)(a[i].wct-a[i].dt);a[i].dczt=a[i].zt/a[i].st;min++;}}else if(flag)for(i=0;i<n;i++){if(a[i].st2>0&&a[i].dt>time){time = a[i].dt;break;}}}}}}printf("\n进程：到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");sum1=0;sum2=0;for(j=0;j<n;j++){for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt ,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("**************************************************************** *****\n");}void fcfs(Gzuo a[])//先到先服务调度{int i,j,min;float sum1,sum2;/*printf("\t请输入进程数(0<n<=50):\t");scanf("%d",&n);while(n>50||n<=0)printf("n\t请重新输入："); scanf("%d",&n);}printf("\n\n");/*struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻float zt; //周转时间float dczt; //带权周转时间 };Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);printf("\n");}*/for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[i-1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i-1].wct+a[i].st;a[i].zt=(float)(a[i].wct-a[i].dt);a[i].dczt=a[i].zt/a[i].st;}}printf("\n进程：到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");sum1=0;sum2=0;for(j=0;j<n;j++){for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt ,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("****************************************************************** ***\n");}void sjf(Gzuo a[])//短作业优先调度{int i,j,min;int b=0,z;float sum1,sum2;/*printf("\n\t\t请输入进程数(0<n<=50):\t"); scanf("%d/n",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);}printf("\n");/*struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);printf("\n");}*/min=a[0].dt;for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}if(a[i].dt==a[i+1].dt&&a[i].st>a[i+1].st) {min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[0].wct) ;else b=b+1;}for(j=b-1;j>=1;j--){for(i=1;i<j;i++){if(a[i].st>a[i+1].st){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}for(i=1;i<n;i++){if(a[i].dt>a[i-1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i-1].wct+a[i].st;a[i].zt=(float)(a[i].wct-a[i].dt); a[i].dczt=a[i].zt/a[i].st;}for(j=i+1,b=j;j<n;j++){if(a[j].dt>a[i].wct) ;else b=b+1;}for(j=b-1;j>=i;j--){for(z=i;z<j;z++){if(a[z].st>a[z+1].st){min=a[z].dt;a[z].dt=a[z+1].dt;a[z+1].dt=min;min=a[z].st;a[z].st=a[z+1].st;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}}printf("\n进程：到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");sum1=0;sum2=0;for(j=0;j<n;j++){ for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt, a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("****************************************************************** ***\n");}void yxj(Gzuo a[])//优先级优先调度{int i,j,min;int b=0,z;float sum1,sum2;/*printf("\n\t\t请输入进程数(0<n<=50):\t");scanf("%d/n",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);}printf("\n");/* struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int yxj; //优先级int wct; //完成时刻float zt; //周转时间float dczt; //带权周转时间 };Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间："); scanf("%d",&a[i].dt);printf("\t服务时间："); scanf("%d",&a[i].st);printf("\t优先级：");scanf("%d",&a[i].yxj);printf("\n");}*/min=a[0].dt;for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min; min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}if(a[i].dt==a[i+1].dt&&a[i].yxj<a[i+1].yxj) {min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[0].wct) ;else b++;}for(j=b-1;j>=1;j--){for(i=1;i<j;i++){if(a[i].yxj<a[i+1].yxj){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}}}for(i=1;i<n;i++){if(a[i].dt>a[i-1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i-1].wct+a[i].st;a[i].zt=(float)(a[i].wct-a[i].dt); a[i].dczt=a[i].zt/a[i].st;}for(j=i+1,b=j;j<n;j++){if(a[j].dt>a[i].wct) ;else b=b+1;}for(j=b-1;j>=i;j--){for(z=i;z<j;z++){if(a[z].yxj<a[z+1].yxj){min=a[z].dt;a[z].dt=a[z+1].dt;a[z+1].dt=min;min=a[z].st;a[z].st=a[z+1].st;a[z+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}}printf("\n进程：到达时间\t服务时间\t优先级\t完成时间\t周转时间\t带权周转时间\n"); sum1=0;sum2=0;for(j=0;j<n;j++){ for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%d\t\t%.0f\t%.2f\n",a[i].id,a[i].dt,a[i].yxj,a[i].st,a[i ].wct,a[i].zt,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("****************************************************************** ***\n");}void main(){ int n;input(a);printf("以下是先到先服务调度：");fcfs(a);printf("以下是短作业优先调度：");sjf(a);printf("以下是时间片轮转法：");sjp(a,sj);printf("以下是优先级优先调度：");yxj(a); }。

抢占优先数调度算法和时间片轮转调度算法

抢占优先数调度算法和时间片轮转调度算法

#include <iostream>#include <stdlib.h>#include <cstring>#include <stdio.h>using namespace std;class pcb{public:char name;int prioORround;int cputime;int count;int needtime;char state;pcb *next;};class createpcb{public:pcb* newpcb(int count){pcb *apcb=new pcb;switch(count){case 1: apcb->name='a';break;case 2: apcb->name='b';break;case 3: apcb->name='c';break;case 4: apcb->name='d';break;case 5: apcb->name='e';break;default: cout<<"错误";}apcb->prioORround=45+rand()%5;apcb->cputime=0;apcb->count=0;apcb->needtime=10+rand()%5;apcb->state='R';apcb->next=NULL;return apcb;}private:pcb *p;};class print{public:void printf(pcb *ready,pcb *tail,pcb *finish,pcb *run){ p=run;cout<<"运行：";while(p->next!=NULL){p=p->next;cout<<p->name<<":"<<p->needtime<<"\t";}p=ready;cout<<"就绪：";while(p->next!=tail){p=p->next;cout<<p->name<<":"<<p->needtime<<"\t";}p=finish;cout<<"完成：";while(p->next!=NULL){p=p->next;cout<<p->name<<":"<<p->needtime<<"\t";}cout<<endl;}private:pcb *p;};class insert1{public:void insert(pcb *ready,pcb *tail){k=ct.newpcb(ready->count);ready->count+=1;p=ready;while(p->next!=tail&&p->next->prioORround>k->prioORround) p=p->next;k->next=p->next;p->next=k;}void insert(pcb *ready,pcb *tail,pcb *finish,pcb *run){ pt.printf(ready,tail,finish,run);k=run->next;k->prioORround-=3;k->cputime+=1;k->needtime-=1;k->state='R';k->next=NULL;run->next=NULL;if(k->needtime>0){p=ready;while(p->next!=tail&&p->next->prioORround>k->prioORround) p=p->next;k->next=p->next;p->next=k;}else{p=finish;while(p->next!=NULL)p=p->next;p->next=k;}}private:pcb *p;pcb *k;createpcb ct;print pt;};class insert2{public:void insert(pcb *ready,pcb *tail){k=ct.newpcb(ready->count);ready->count+=1;p=ready;while(p->next!=tail)p=p->next;k->next=p->next;p->next=k;void insert(pcb *ready,pcb *tail,pcb *finish,pcb *run){ pt.printf(ready,tail,finish,run);k=run->next;k->cputime+=2;k->needtime-=2;k->state='R';k->next=NULL;run->next=NULL;if(k->needtime>0){p=ready;while(p->next!=tail)p=p->next;k->next=p->next;p->next=k;}else{p=finish;while(p->next!=NULL)p=p->next;p->next=k;}}private:pcb *p;pcb *k;createpcb ct;print pt;};class firstin{public:void runs(pcb *ready,pcb *tail,pcb *run){if(ready->next!=tail){p=run;p->next=ready->next;p=p->next;ready->next=p->next;p->state='W';p->next=NULL;}private:pcb *p;};class prisch{public:prisch(){system("cls");='R';ready.count=1;='T';='F';ready.next=&tail;tail.next=NULL;finish.next=NULL;run.next=NULL;printf("\t\t\t优先级数调度\n");while(1){if(ready.count<=5)inst.insert(&ready,&tail);fir.runs(&ready,&tail,&run);inst.insert(&ready,&tail,&finish,&run);if(ready.next==&tail)break;}pt.printf(&ready,&tail,&finish,&run);getchar();}private:pcb *p;pcb ready;pcb tail;pcb finish;pcb run;insert1 inst;firstin fir;print pt;string algo;};class roundsch{public:roundsch(){system("cls");='R';ready.count=1;='T';='F';ready.next=&tail;tail.next=NULL;finish.next=NULL;run.next=NULL;printf("\t\t\t时间片轮转调度\n");while(1){if(ready.count<=5)inst.insert(&ready,&tail);fir.runs(&ready,&tail,&run);inst.insert(&ready,&tail,&finish,&run);if(ready.next==&tail)break;}pt.printf(&ready,&tail,&finish,&run);getchar();}private:pcb *p;pcb ready;pcb tail;pcb finish;pcb run;insert2 inst;firstin fir;print pt;};class menu{public:menu(){char c;bool z=false;while(1){system("cls");cout<<"\n\n\n\t\t*****抢占优先数调度算法和时间片轮转调度算法******\n\n"<<endl<<"\t\t*\t\t\t1,优先级数调度\t\t*\n"<<endl<<"\t\t*\t\t2,时间片轮转调度\t\t*\n"<<endl<<"\t\t*\t3,退出程序\t\t\t\t*\n"<<endl<<"\t\t*************************************************\ n"<<endl;if(z==true){cout<<"\t\t\t\t选择输入错误！"<<endl;z=false;}cout<<"\t\t请输入选择：";scanf("%c",&c);getchar();if(c=='1') prisch prisch;else if(c=='2') roundsch roundsch;else if(c=='3'){cout<<"\n\n\t\t\t";exit(0);}else z=true;}}};int main(int args,char** argv) {menu menu;return 0;}。

时间片轮转调度算法

时间片轮转调度算法

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

显示函数：在进程调度前、调度中和调度后进行显示。

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

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

并在执行一个时间片后化，服务时间变化，状态变化。

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

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

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

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

4、时间片大小可以不为1，但至少实现时间片大小为1的RR调度。

优先调度、时间片轮转

优先调度、时间片轮转

优先调度 & 时间片轮转优先调度优先调度，是一种高级的进程调度算法，它赋予了进程及其资源的不同重要性。

在优先调度中，操作系统会优先运行最紧急（最高优先级）的进程。

举个例子，某个进程 A 需要进行网络请求，而进程 B 是一个计算密集型任务，此时操作系统会将进程 A 定义为更高优先级的任务，这样它就可以立即获得资源并得到及时处理。

优先调度的优点是可以确保资源的及时分配，缺点是可能会导致低优先级的进程饥饿。

如果某些进程的优先级比较低，它们可能永远无法获得资源，因为高优先级的进程会一直抢占资源。

时间片轮转时间片轮转是一种常用的进程调度算法。

它是一种基于时间片的算法，旨在确保所有进程都能获得公平的CPU时间。

时间片是操作系统给每个进程分配的时间量。

当进程运行时，它会对时间片进行使用。

当时间片用完后，操作系统会把当前进程暂停，并将其他进程加入运行队列。

这个过程会一直持续下去，每个进程都有机会被调度。

与优先调度算法不同，时间片轮转算法不考虑优先级。

任何一个就绪进程都有被调度的机会，这个过程是公平且均匀的。

优先调度和时间片轮转算法不是互斥的，并且通常会结合在一起使用。

优先调度可以用于及时响应某些场景，例如I/O请求，而时间片轮转可以确保CPU分配公平并避免进程饥饿情况的出现。

在选择进程调度算法时，我们需要考虑不同的因素。

优先调度算法可以确保及时响应某些场景，时间片轮转算法可以确保CPU分配公平并避免进程饥饿情况的出现。

因此，在实际应用中，我们可以根据情况选择最合适的算法。

【精品】进程模拟调度时间片和优先级

【精品】进程模拟调度时间片和优先级

仲恺农业工程学院课程设计进程调度模拟算法实现（优先数算法和时间片算法）课程名称计算机系统开发综合训练（2）姓名杜松耀院(系）信息科学与技术学院专业班级计算机科学与技术121学号2指导教师史婷婷目录1需求分析............................................ 错误!未指定书签。

2概要设计............................................ 错误!未指定书签。

2.1实验原理....................................... 错误!未指定书签。

2。

2数据结构...................................... 错误!未指定书签。

2.3算法描述....................................... 错误!未指定书签。

2.4算法流程图..................................... 错误!未指定书签。

3详细设计............................................ 错误!未指定书签。

3.1源程序代码..................................... 错误!未指定书签。

4调试分析............................................ 错误!未指定书签。

5总结................................................ 错误!未指定书签。

1需求分析本实验完成的系统是进程调度模拟算法实现（优先数算法和时间片算法)，进程是操作系统中最基本、最重要的概念，是在多道程序系统出现后，为了刻画系统内部的动态状况、描述运行程序的活动规律而引进的新概念，所有多道程序设计操作系统程序设计操作系统都建立在进程的基础上。

进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。

优先级和时间片轮转调度

优先级和时间片轮转调度
}
for(j=0;j<processnum;j++)
{q=processarray[j];
printf("\n检查进程%3c是否结束,进程当前状态:%3d",q->name,qgame is over!\n");
}
void main()
{
*processarray=createprocess(processarray);
#include "stdio.h"
#include <malloc.h>
#define max 100
#define etime 4
#define pfree 0
#define running 1
#define aready 2
#define blocking 3
typedef struct node
{
char name;
int status;
int pri;
int ptime;
int ax,bx,cx,dx;
int pc;
int psw;
}pcb;
pcb *processarray[max];
static int processnum;
pcb *createprocess(pcb *processarray[])组
q->status=aready;
totaltime-=etime;}
if(i<processnum-1)
i++;
else if(i==processnum-1)
i=0;
}}
void processStaPri(pcb *processarray[])

【精选】实验二 带优先级的时间片轮换的进程调度算法的实现实验二 带优先级的时间片轮换的进程调度算法的

【精选】实验二 带优先级的时间片轮换的进程调度算法的实现实验二 带优先级的时间片轮换的进程调度算法的

•
struct pcb
•
{ /* 定义进程控制块PCB */
•
char name[10] ;
•
char state ;
•
in t super;
•
in t needtime ;
•
in t runtime ;
•
struct pcb* link ;
•
}
• *ready=NULL,*p;
•
typedef struct pcb PCB;
•
free (p) ;
•
}
•}
•}
• vo id process ( ) / / 对 输 入 命 令 的 处 理
• { int i = 0 , ii = 0 ;
• for ( i = 0 ; i<7 ; i++)
•
if (st r icmp (str , command [ i]) = = 0)
•
break ;
•
}
•
}
•
}
• if ( i = =MAXPIOR)
•
pr intf ( " In vaild process number . " ) ;
• else
•
if (p - >state = = 2)
•
pr intf ( " the process %d has blocked , cannot sleep again ! " , p - > ident)
•
else
•
p - >state = 2 ;
• ps () ;
•}

时间片轮转算法和优先级调度算法C语言模拟实现收藏

时间片轮转算法和优先级调度算法C语言模拟实现收藏

时间片轮转算法和优先级调度算法C语言模拟实现收藏一、目的和要求进程调度是处理机管理的核心内容。

本实验要求用高级语言编写模拟进程调度程序，以便加深理解有关进程控制快、进程队列等概念，并体会和了解优先数算法和时间片轮转算法的具体实施办法。

二、实验内容1.设计进程控制块PCB的结构，通常应包括如下信息：进程名、进程优先数（或轮转时间片数）、进程已占用的CPU时间、进程到完成还需要的时间、进程的状态、当前队列指针等。

2.编写两种调度算法程序：优先数调度算法程序循环轮转调度算法程序3.按要求输出结果。

三、提示和说明分别用两种调度算法对伍个进程进行调度。

每个进程可有三种状态；执行状态（R UN）、就绪状态（READY,包括等待状态）和完成状态（FINISH），并假定初始状态为就绪状态。

（一）进程控制块结构如下：NAME——进程标示符PRIO/ROUND——进程优先数/进程每次轮转的时间片数（设为常数2）CPUTIME——进程累计占用CPU的时间片数NEEDTIME——进程到完成还需要的时间片数STATE——进程状态NEXT——链指针注：1.为了便于处理，程序中进程的的运行时间以时间片为单位进行计算；2.各进程的优先数或轮转时间片数，以及进程运行时间片数的初值，均由用户在程序运行时给定。

（二）进程的就绪态和等待态均为链表结构，共有四个指针如下：RUN——当前运行进程指针READY——就需队列头指针TAIL——就需队列尾指针FINISH——完成队列头指针（三）程序说明1. 在优先数算法中，进程优先数的初值设为：50-NEEDTIME每执行一次，优先数减1，CPU时间片数加1，进程还需要的时间片数减1。

在轮转法中，采用固定时间片单位（两个时间片为一个单位），进程每轮转一次，CPU时间片数加2，进程还需要的时间片数减2，并退出CPU，排到就绪队列尾，等待下一次调度。

2. 程序的模块结构提示如下：整个程序可由主程序和如下7个过程组成：（1）INSERT1——在优先数算法中，将尚未完成的PCB按优先数顺序插入到就绪队列中；（2）INSERT2——在轮转法中，将执行了一个时间片单位（为2），但尚未完成的进程的PCB，插到就绪队列的队尾；（3）FIRSTIN——调度就绪队列的第一个进程投入运行；（4）PRINT——显示每执行一次后所有进程的状态及有关信息。

进程调度模拟设计——时间片轮转、优先级法 程序

进程调度模拟设计——时间片轮转、优先级法 程序
rq = new rnode;
rq->next = NULL;
rq->pname = dp->pname;
rq->ctime = dp->ctime;
rq->rtime = dp->rtime;
rq->stime = dp->stime;
{
if(dp->bb != 1)
{
dp->stime = letime;
dp->bb = 1;
}
if(dp->rrtime > time)
{
dp->etime = letime + time;
dp->rrtime = dp->rrtime - time;
nn = inhead->yx;
num = inhead->num;
bb = 1;
}
inhead = inhead->next;
}
if(bb == 1)
{
inhead = head->next;
while(inhead)
while(inhead)
{
if(inhead->bj != 1)
{
rq = new rnode;
rq->next = NULL;
rq->pname = inhead->pname;
rq->ctime = inhead->ctime;
rq->etime = letime;
rq->ztime = rq->etime - rq->ctime;

实验报告：模拟时间片轮转和优先级调度算法

实验报告：模拟时间片轮转和优先级调度算法

1．实验内容（时间片轮转和优先级调度算法）（1）用C/C++/JA V A等语言来实现对N个进程采用优先权调度和时间片轮转调度。

（2）每个用来标识进程的进程控制块PCB用结构来描述，可能需要包括以下字段：⏹进程标识数ID。

⏹进程优先数PRIORITY，并规定优先数越小的进程，其优先权越高。

⏹进程已占用的CPU时间CPUTIME。

（初始都为0）⏹进程总的需要运行的时间ALLTIME。

⏹进程剩余运行时间remainTime, 当进程运行完毕时，remainTime变为0。

⏹进程的结束时间finishTime, 当进程结束时，“系统”的时间，计算周转时间用⏹进程状态STATE。

（就绪，运行，结束，根据需要决定是否使用）（3）输出：为观察进程调度是否正确，应输出进程的“执行”过程。

但是注意，我们是模拟进程执行，所以进程并不会真正“执行”，只是输出进程执行的先后顺序，和进程执行，结束的时间点。

对于时间片轮转，应该每个时间片输出一次----------------------------------------------------------Id pri cpuTime allTime0 4 3 41 32 60 4 3 4对于优先权调度，每次调度输出一次，进行的结束时间，依次输出调度进程的信息最后输出进程的周转时间，带权周转时间和系统平均周转时间等（4）实验数据：作业执行时间优先数----------------------1 10 32 6 13 2 44 4 55 8 2如果使用时间片调度算法，请自行设定时间片（如1，2等），并比较不同时间片下的周转时间等（5）实验设计：实验的小数据量使用数组或链表都可以，但考虑到真实的应用经常要删除和添加PCB，应该使用链表，如果涉及动态的插入删除，并且需要随时找最大/最小，也可以考虑用树/堆等其他数据结构（如C++中的优先级队列）。

（6）提高要求：给每个进程增加“到达”时间，重新计算优先级调度的各个结果，并验证结果是否正确2．实验目的通过模拟进程调度算法加深对进程调度的理解3．实验原理（1）周转时间：●概念：作业提交到操作系统开始到作业完成的时间包括四个部分：1、从外存中后备队列等待作业调度（高级调度）的时间2、进程在就绪队列等待进程调度（低级调度）的时间3、进程在cpu执行的时间4、进程等待IO操作完成的时间●计算：1、周转时间= 作业完成时间- 作业提交时间2、平均周转时间= 各作业周转时间之和/ 作业数3、带权周转时间= 作业周转时间/ 作业实际运行时间4、平均带权周转时间= 各作业带权周转时间之和/ 作业数（2）等待时间：1、进程/作业处于等待处理机状态时间之和2、对于进程：进程建立后等待被服务的时间之和3、对于作业：除了进程建立后的等待还包括作业在外存后备队列中等待的时间4、相应时间：用户提交请求到首次产生相应所用的时间（3）时间片轮转：●思想：公平、轮流为每个进程服务、每个进程在一定时间内得到相应●规则：按照到达就绪队列的顺序，轮流让各个进程执行一个时间片。

进程调度 先来先服务 时间片轮转法 优先服务调度处理器调度 免费下载 C或C++

进程调度 先来先服务 时间片轮转法 优先服务调度处理器调度 免费下载 C或C++
}
}
}
return head;//返回队首
printf("输入第%d个进程的名字、到达时间、服务时间:\n",i+1);
scanf("%s%d%d",&p->name,&p->daodatime,&p->fuwutime);
p->shengyutime=p->fuwutime;
p->state="就绪";
head=rear=NULL;//初始化队首和队尾为空
printf("请输入进程数目：");
scanf("%d",&a);
for(i=0;i<a;i++)
{
p=(struct shijian*)malloc(sizeof(struct shijian)); //初始化一个空间给进程进入
{ int k;
for(k=0;k<=N-1;k++)
{
if(k==0)//K=0,表示第一个进程到达
{
p[k].kaishitime=p[k].daodatime;//那么开始时间=到达时间
p[k].wanchengtime=p[k].daodatime+p[k].fuwutime;//完成时间=到达时间+服务时间
{
fcfs temp;//在结构体中定义第三个变量进行交换
temp=p[i];
p[i]=p[j];
p[j]=temp;
}
}
//核心的运行阶段
void deal(fcfs *p, float daodatime,float fuwutime,float kaishitime,float wanchengtime,float zhouztime,float daiquantime,int N)

实现模拟进程调度的算法：时间片轮转及短进程优先

实现模拟进程调度的算法：时间片轮转及短进程优先

操作系统课程设计报告时间：2011-12-26～2012-1-6地点：信息技术实验中心计算机科学与技术（或软件工程）专业xxx级xxx班xx号xxxxxxxx目录一课程设计的目的和意义………………………………………………………二进程调度算法模拟……………………………………………………………1 设计目的………………………………………………………………………2 设计要求………………………………………………………………………3 时间片轮转算法模拟…………………………………………………………4 先来先服务算法模拟…………………………………………………………三主存空间的回收与分配………………………………………………………1 设计目的………………………………………………………………………2 设计要求………………………………………………………………………3 模拟算法的实现………………………………………………………………四模拟DOS文件的建立和使用…………………………………………………1 设计目的………………………………………………………………………2 设计要求………………………………………………………………………3 模拟算法的实现………………………………………………………………五磁盘调度………………………………………………………………………1 设计目的………………………………………………………………………2 设计要求………………………………………………………………………3 模拟算法的实现………………………………………………………………六总结……………………………………………………………………………一、课程设计的目的和意义本次操作系统课程设计的主要任务是进行系统级的程序设计。

本课程设计是操作系统原理课程的延伸。

通过该课程设计，使学生更好地掌握操作系统各部分结构、实现机理和各种典型算法，加深对操作系统的设计和实现思路的理解，培养学生的系统设计和动手能力，学会分析和编写程序。

时间片轮转调度算法

时间片轮转调度算法

时间片轮转调度算法部门： xxx时间： xxx整理范文，仅供参考，可下载自行编辑// 时间片轮转调度算法#include <iostream>#include <cstdio>#include <cmath>#include <cstring>using namespace std。

enum STATUS {RUN,READY,WAIT,FINISH}。

struct PCBNode{int processID。

//进程ID b5E2RGbCAPSTATUS status。

//进程状态 p1EanqFDPwint priorityNum。

//优先数 int reqTime。

//总的需要运行时间 DXDiTa9E3dint remainTime。

//剩下需要运行时间int arriveTime。

//进入就绪队列时间int startTime。

//开始运行时间int finishTime。

//结束运行时间int totalTime。

//周转时间float weightTotalTime。

//带权周转时间}。

struct QueueNode{int ID。

//进程IDstruct QueueNode * next。

//队列中下一个进程指针}。

struct LinkQueue{QueueNode *head。

//队首}。

void Fcfs(LinkQueue& Q, int& totalTimeSum, int& weightTotalTimeSum,PCBNode * ProcessTable>。

RTCrpUDGiT bool RR_Run(LinkQueue& Q,QueueNode* q, QueueNode* p, const int Round,int& currentTime,PCBNode * ProcessTable>。

时间片轮转算法及优先级调度算法C语言模拟实现收藏

时间片轮转算法及优先级调度算法C语言模拟实现收藏

时间片轮转算法及优先级调度算法C语言模拟实现收藏时间片轮转算法是一种常见的CPU调度算法，通过将进程按照到达顺序放置在一个就绪队列中，并且给予每个进程相同的时间片，当进程用完时间片后，将其放到队列的尾部，轮流执行其他进程。

优先级调度算法是根据进程的优先级来决定下一个执行的进程。

下面是使用C语言模拟实现时间片轮转算法和优先级调度算法的代码：```c#include <stdio.h>typedef structchar name[10];int arrivalTime;int burstTime;int remainingTime;} Process;int totalTurnaroundTime = 0;int totalWaitingTime = 0;//初始化每个进程的剩余执行时间for (int i = 0; i < numProcesses; i++)processes[i].remainingTime = processes[i].burstTime;}while (1)int allProcessesFinished = 1; // 标记所有进程是否执行完毕for (int i = 0; i < numProcesses; i++)if (processes[i].remainingTime > 0)allProcessesFinished = 0; // 还有未执行完毕的进程processes[i].remainingTime = 0;} else}printf("%s执行完毕，剩余时间：%d\n", processes[i].name, processes[i].remainingTime);}}if (allProcessesFinished)break; // 所有进程执行完毕，退出循环}}//计算平均周转时间和平均等待时间float averageTurnaroundTime = (float)totalTurnaroundTime / numProcesses;float averageWaitingTime = (float)totalWaitingTime / numProcesses;printf("平均周转时间：%.2f\n", averageTurnaroundTime);printf("平均等待时间：%.2f\n", averageWaitingTime);int maiint numProcesses;printf("请输入进程数量：");scanf("%d", &numProcesses);Process processes[numProcesses];for (int i = 0; i < numProcesses; i++)printf("请输入进程%d的名称、到达时间和执行时间：", i+1);scanf("%s%d%d", processes[i].name, &processes[i].arrivalTime, &processes[i].burstTime);}printf("请输入时间片大小：");return 0;```优先级调度算法：```c#include <stdio.h>typedef structchar name[10];int arrivalTime;int burstTime;int priority;int waitingTime;int turnaroundTime;} Process;void runPriority(Process* processes, int numProcesses)int totalWaitingTime = 0;int totalTurnaroundTime = 0;//对进程按照到达时间进行排序for (int i = 0; i < numProcesses; i++)for (int j = 0; j < numProcesses-i-1; j++)if (processes[j].arrivalTime > processes[j+1].arrivalTime) Process temp = processes[j];processes[j] = processes[j+1];processes[j+1] = temp;}}}processes[0].waitingTime = 0;//计算每个进程的等待时间和周转时间for (int i = 1; i < numProcesses; i++)processes[i].waitingTime = processes[i-1].waitingTime + processes[i-1].burstTime;processes[i].turnaroundTime = processes[i].waitingTime + processes[i].burstTime;totalWaitingTime += processes[i].waitingTime;totalTurnaroundTime += processes[i].turnaroundTime;}//计算平均等待时间和平均周转时间float averageWaitingTime = (float)totalWaitingTime / numProcesses;float averageTurnaroundTime = (float)totalTurnaroundTime / numProcesses;printf("平均等待时间：%.2f\n", averageWaitingTime);printf("平均周转时间：%.2f\n", averageTurnaroundTime);int maiint numProcesses;printf("请输入进程数量：");scanf("%d", &numProcesses);Process processes[numProcesses];for (int i = 0; i < numProcesses; i++)printf("请输入进程%d的名称、到达时间、执行时间和优先级：", i+1);scanf("%s%d%d%d", processes[i].name,&processes[i].arrivalTime, &processes[i].burstTime,&processes[i].priority);}runPriority(processes, numProcesses);return 0;```通过输入进程的信息，可以计算出使用时间片轮转算法和优先级调度算法的平均等待时间和平均周转时间，从而比较它们的效果。

操作系统时间片轮转算法与优先级调度算法

操作系统时间片轮转算法与优先级调度算法

#include "stdio.h"#include "stdlib.h"#include "string.h"typedef struct node{char name[10]; /*进程标识符*/int prio; /*进程优先数*/int round; /*进程时间轮转时间片*/int cputime; /*进程占用CPU时间*/int needtime; /*进程到完成还要的时间*/int count; /*计数器*/char state; /*进程的状态*/struct node *next; /*链指针*/}PCB;PCB *finish,*ready,*tail,*run; /*队列指针*/int N; /*进程数*//*将就绪队列中的第一个进程投入运行*/firstin(){run=ready; /*就绪队列头指针赋值给运行头指针*/run->state='R'; /*进程状态变为运行态*/ready=ready->next; /*就绪对列头指针后移到下一进程*/}/*标题输出函数*/void prt1(char a){if(toupper(a)=='P') /*优先数法*/printf(" name cputime needtime priority state\n");elseprintf(" name cputime needtime count round state\n"); }/*进程PCB输出*/void prt2(char a,PCB *q){if(toupper(a)=='P') /*优先数法的输出*/printf(" %-10s%-10d%-10d%-10d %c\n",q->name,q->cputime,q->needtime,q->prio,q->state);else/*轮转法的输出*/printf(" %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,q->cputime,q->needtime,q->count,q->round,q->state);}/*输出函数*/void prt(char algo){PCB *p;prt1(algo); /*输出标题*/if(run!=NULL) /*如果运行指针不空*/prt2(algo,run); /*输出当前正在运行的PCB*/p=ready; /*输出就绪队列PCB*/while(p!=NULL){prt2(algo,p);p=p->next;}p=finish; /*输出完成队列的PCB*/while(p!=NULL){prt2(algo,p);p=p->next;}p=ready;printf("就绪队列：");while(p!=NULL){printf("%s\t",p->name); p=p->next;}printf("\n");p=finish;printf("完成队列：");while(p!=NULL){printf("%s\t",p->name); p=p->next;}printf("\n");getch(); /*压任意键继续*/ }/*优先数的插入算法*/insert1(PCB *q){PCB *p1,*s,*r;int b;s=q; /*待插入的PCB指针*/p1=ready; /*就绪队列头指针*/r=p1; /*r做p1的前驱指针*/b=1;while((p1!=NULL)&&b) /*根据优先数确定插入位置*/if(p1->prio>=s->prio){r=p1;p1=p1->next;}elseb=0;if(r!=p1) /*如果条件成立说明插入在r与p1之间*/{r->next=s;s->next=p1;}else{s->next=p1; /*否如此插入在就绪队列的头*/ready=s;}}/*轮转法插入函数*/insert2(PCB *p2){tail->next=p2; /*将新的PCB插入在当前就绪队列的尾*/ tail=p2;p2->next=NULL;}/*优先数创建初始PCB信息*/void create1(char alg){PCB *p;int i,time;char na[10];ready=NULL; /*就绪队列头指针*/finish=NULL; /*完成队列头指针*/run=NULL; /*运行队列指针*/printf("Enter name and time of process\n"); /*输入进程标识和所需时间创建PCB*/for(i=1;i<=N;i++){p=malloc(sizeof(PCB));scanf("%s",na);scanf("%d",&time);strcpy(p->name,na);p->cputime=0;p->needtime=time;p->state='W';p->prio=50-time;if(ready!=NULL) /*就绪队列不空调用插入函数插入*/insert1(p);else{p->next=ready; /*创建就绪队列的第一个PCB*/ready=p;}}// clrscr();system("CLS");printf(" output of priority:\n");printf("************************************************\n"); prt(alg); /*输出进程PCB信息*/run=ready; /*将就绪队列的第一个进程投入运行*/ready=ready->next;run->state='R';}/*轮转法创建进程PCB*/void create2(char alg){PCB *p;int i,time;char na[10];ready=NULL;finish=NULL;run=NULL;printf("Enter name and time of round process\n");for(i=1;i<=N;i++){p=malloc(sizeof(PCB));scanf("%s",na);scanf("%d",&time);strcpy(p->name,na);p->cputime=0;p->needtime=time;p->count=0; /*计数器*/p->state='W';p->round=2; /*时间片*/if(ready!=NULL)insert2(p);else{p->next=ready;ready=p;tail=p;}}//clrscr();system("CLS");printf(" output of round\n");printf("************************************************\n"); prt(alg); /*输出进程PCB信息*/run=ready; /*将就绪队列的第一个进程投入运行*/ready=ready->next;run->state='R';}/*优先数调度算法*/priority(char alg){while(run!=NULL) /*当运行队列不空时，有进程正在运行*/{run->cputime=run->cputime+1;run->needtime=run->needtime-1;run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/if(run->needtime==0) /*如所需时间为0将其插入完成队列*/{run->next=finish;finish=run;run->state='F'; /*置状态为完成态*/run=NULL; /*运行队列头指针为空*/if(ready!=NULL) /*如就绪队列不空*/firstin(); /*将就绪对列的第一个进程投入运行*/}else /*没有运行完同时优先数不是最大，如此将其变为就绪态插入到就绪队列*/if((ready!=NULL)&&(run->prio<ready->prio)){run->state='W';insert1(run);firstin(); /*将就绪队列的第一个进程投入运行*/}prt(alg); /*输出进程PCB信息*/}}/*时间片轮转法*/roundrun(char alg){while(run!=NULL){run->cputime=run->cputime+1;run->needtime=run->needtime-1;run->count=run->count+1;if(run->needtime==0)/*运行完将其变为完成态，插入完成队列*/{run->next=finish;finish=run;run->state='F';run=NULL;if(ready!=NULL)firstin(); /*就绪对列不空，将第一个进程投入运行*/}elseif(run->count==run->round) /*如果时间片到*/{run->count=0; /*计数器置0*/if(ready!=NULL) /*如就绪队列不空*/{run->state='W'; /*将进程插入到就绪队列中等待轮转*/ insert2(run);firstin(); /*将就绪对列的第一个进程投入运行*/}}prt(alg); /*输出进程信息*/}}/*主函数*/main(){char algo; /*算法标记*///clrscr();system("CLS");printf("type the algorithm:P/R(priority/roundrobin)\n");scanf("%c",&algo); /*输入字符确定算法*/ printf("Enter process number\n");scanf("%d",&N); /*输入进程数*/if(algo=='P'||algo=='p'){create1(algo); /*优先数法*/priority(algo);}elseif(algo=='R'||algo=='r'){create2(algo); /*轮转法*/roundrun(algo);}}。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

时间片轮转算法和优先级调度算法C语言模拟实现收藏一、目的和要求进程调度是处理机管理的核心内容。

本实验要求用高级语言编写模拟进程调度程序，以便加深理解有关进程控制快、进程队列等概念，并体会和了解优先数算法和时间片轮转算法的具体实施办法。

二、实验内容1.设计进程控制块PCB的结构，通常应包括如下信息：进程名、进程优先数（或轮转时间片数）、进程已占用的CPU时间、进程到完成还需要的时间、进程的状态、当前队列指针等。

2.编写两种调度算法程序：优先数调度算法程序循环轮转调度算法程序3.按要求输出结果。

三、提示和说明分别用两种调度算法对伍个进程进行调度。

每个进程可有三种状态；执行状态（R UN）、就绪状态（READY,包括等待状态）和完成状态（FINISH），并假定初始状态为就绪状态。

（一）进程控制块结构如下：NAME——进程标示符PRIO/ROUND——进程优先数/进程每次轮转的时间片数（设为常数2）CPUTIME——进程累计占用CPU的时间片数NEEDTIME——进程到完成还需要的时间片数STATE——进程状态NEXT——链指针注：1.为了便于处理，程序中进程的的运行时间以时间片为单位进行计算；2.各进程的优先数或轮转时间片数，以及进程运行时间片数的初值，均由用户在程序运行时给定。

（二）进程的就绪态和等待态均为链表结构，共有四个指针如下：RUN——当前运行进程指针READY——就需队列头指针TAIL——就需队列尾指针FINISH——完成队列头指针（三）程序说明1. 在优先数算法中，进程优先数的初值设为：50-NEEDTIME每执行一次，优先数减1，CPU时间片数加1，进程还需要的时间片数减1。

在轮转法中，采用固定时间片单位（两个时间片为一个单位），进程每轮转一次，CPU时间片数加2，进程还需要的时间片数减2，并退出CPU，排到就绪队列尾，等待下一次调度。

2. 程序的模块结构提示如下：整个程序可由主程序和如下7个过程组成：（1）INSERT1——在优先数算法中，将尚未完成的PCB按优先数顺序插入到就绪队列中；（2）INSERT2——在轮转法中，将执行了一个时间片单位（为2），但尚未完成的进程的PCB，插到就绪队列的队尾；（3）FIRSTIN——调度就绪队列的第一个进程投入运行；（4）PRINT——显示每执行一次后所有进程的状态及有关信息。

（5）CREATE——创建新进程，并将它的PCB插入就绪队列；（6）PRISCH——按优先数算法调度进程；（7）ROUNDSCH——按时间片轮转法调度进程。

主程序定义PCB结构和其他有关变量。

（四）运行和显示程序开始运行后，首先提示：请用户选择算法，输入进程名和相应的NEEDTIM E值。

每次显示结果均为如下5个字段：name cputime needtime priority state注：1．在state字段中，"R"代表执行态，"W"代表就绪（等待）态，"F"代表完成态。

2．应先显示"R"态的，再显示"W"态的，再显示"F"态的。

3．在"W"态中，以优先数高低或轮转顺序排队；在"F"态中，以完成先后顺序排队。

view plaincopy to clipboardprint?1./*2.操作系统实验之时间片轮转算法和优先级调度算法3.By Visual C++ 6.04.*/#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct node{char name[20]; /*进程的名字*/int prio; /*进程的优先级*/int round; /*分配CPU的时间片*/int cputime; /*CPU执行时间*/int needtime; /*进程执行所需要的时间*/char state; /*进程的状态，W——就绪态，R——执行态，F——完成态*/int count; /*记录执行的次数*/struct node *next; /*链表指针*/}PCB;PCB *ready=NULL,*run=NULL,*finish=NULL; /*定义三个队列，就绪队列，执行队列和完成队列*/int num;void GetFirst(); /*从就绪队列取得第一个节点*/void Output(); /*输出队列信息*/void InsertPrio(PCB *in); /*创建优先级队列，规定优先数越小，优先级越高* /void InsertTime(PCB *in); /*时间片队列*/void InsertFinish(PCB *in); /*时间片队列*/void PrioCreate(); /*优先级输入函数*/void TimeCreate(); /*时间片输入函数*/void Priority(); /*按照优先级调度*/void RoundRun(); /*时间片轮转调度*/int main(void){char chose;printf("请输入要创建的进程数目:\n");scanf("%d",&num);getchar();printf("输入进程的调度方法：(P/R)\n");scanf("%c",&chose);switch(chose){case 'P':case 'p':PrioCreate();Priority();break;case 'R':case 'r':TimeCreate();RoundRun();break;default:break;}Output();return 0;}void GetFirst() /*取得第一个就绪队列节点*/{run = ready;if(ready!=NULL){run ->state = 'R';ready = ready ->next;run ->next = NULL;}}void Output() /*输出队列信息*/{PCB *p;p = ready;printf("进程名\t优先级\t轮数\tcpu时间\t需要时间\t进程状态\t计数器\n ");while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p ->round,p->cputime,p->needtime,p->state,p->count);p = p->next;}p = finish;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p ->round,p->cputime,p->needtime,p->state,p->count);p = p->next;}p = run;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p ->round,p->cputime,p->needtime,p->state,p->count);p = p->next;}}void InsertPrio(PCB *in) /*创建优先级队列，规定优先数越小，优先级越低* /{PCB *fst,*nxt;fst = nxt = ready;if(ready == NULL) /*如果队列为空，则为第一个元素*/{in->next = ready;ready = in;}else /*查到合适的位置进行插入*/{if(in ->prio >= fst ->prio) /*比第一个还要大，则插入到队头*/{in->next = ready;ready = in;}else{while(fst->next != NULL) /*移动指针查找第一个别它小的元素的位置进行插入*/{nxt = fst;fst = fst->next;}if(fst ->next == NULL) /*已经搜索到队尾，则其优先级数最小，将其插入到队尾即可*/{in ->next = fst ->next;fst ->next = in;}else /*插入到队列中*/{nxt = in;in ->next = fst;}}}}void InsertTime(PCB *in) /*将进程插入到就绪队列尾部*/{PCB *fst;fst = ready;if(ready == NULL){ready = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void InsertFinish(PCB *in) /*将进程插入到完成队列尾部*/ {PCB *fst;fst = finish;if(finish == NULL){in->next = finish;finish = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;}}void PrioCreate() /*优先级调度输入函数*/{PCB *tmp;int i;printf("输入进程名字和进程所需时间：\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar(); /*吸收回车符号*/scanf("%d",&(tmp->needtime));tmp ->cputime = 0;tmp ->state ='W';tmp ->prio = 50 - tmp->needtime; /*设置其优先级，需要的时间越多，优先级越低*/tmp ->round = 0;tmp ->count = 0;InsertPrio(tmp); /*按照优先级从高到低，插入到就绪队列*/}}void TimeCreate() /*时间片输入函数*/{PCB *tmp;int i;printf("输入进程名字和进程时间片所需时间：\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar();scanf("%d",&(tmp->needtime));tmp ->cputime = 0;tmp ->state ='W';tmp ->prio = 0;tmp ->round = 2; /*假设每个进程所分配的时间片是2*/tmp ->count = 0;InsertTime(tmp);}}void Priority() /*按照优先级调度，每次执行一个时间片*/{int flag = 1;GetFirst();while(run != NULL) /*当就绪队列不为空时，则调度进程如执行队列执行* /{Output(); /*输出每次调度过程中各个节点的状态*/while(flag){run->prio -= 3; /*优先级减去三*/run->cputime++; /*CPU时间片加一*/run->needtime--;/*进程执行完成的剩余时间减一*/if(run->needtime == 0)/*如果进程执行完毕，将进程状态置为F，将其插入到完成队列*/{run ->state = 'F';run->count++; /*进程执行的次数加一*/InsertFinish(run);flag = 0;}else /*将进程状态置为W，入就绪队列*/{run->state = 'W';run->count++; /*进程执行的次数加一*/InsertTime(run);flag = 0;}}flag = 1;GetFirst(); /*继续取就绪队列队头进程进入执行队列*/}}void RoundRun() /*时间片轮转调度算法*/{int flag = 1;GetFirst();while(run != NULL){Output();while(flag){run->count++;run->cputime++;run->needtime--;if(run->needtime == 0) /*进程执行完毕*/{run ->state = 'F';InsertFinish(run);flag = 0;}else if(run->count == run->round)/*时间片用完*/ {run->state = 'W';run->count = 0; /*计数器清零，为下次做准备*/ InsertTime(run);flag = 0;}}flag = 1;GetFirst();}}。

相关文档
最新文档