您的位置：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[])
  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();}}。

相关文档
最新文档