时间片轮转调度算法.docx
《时间片轮转调度算法.docx》由会员分享，可在线阅读，更多相关《时间片轮转调度算法.docx（14页珍藏版）》请在冰豆网上搜索。
时间片轮转调度算法
#include
#include
#include
#include
/*进程控制块数据结构*/
typedefstructnode
{
charname[10];/*进程名*/
intprio;/*进程优先级*/
intround;/*循环轮转法进程每次轮转的时间片*/
intcputime;/*进程累计消耗的CUP时间*/
intneedtime;/*进程到完成还需要的CUP时间*/
intcount;/*循环轮转法一个时间片进程运行时间*/
charstate;/*进程的状态：
'R':
运行,'W'：
等待,'F'：
结束*/
structnode*next;/*指向下一个进程的链指针*/
}PCB;
PCB*finish,*ready,*tail,*run;/*指向三个队列的队首的指针，
finish为完成队列头指针，
ready为就绪队列头指针，
tail为就绪队列的队尾指针，
run为当前运行进程头指针*/
intN;/*定义进程的数目*/
voidfirstin（void）;//调度就绪队列的第一个进程投入运行；
voidprint1（chara）;//打印表头行信息
voidprint2（charchose,PCB*p）;//打印每一行的状态信息
voidprint（charchose）;//打印每执行一次算法后所有的进程的状态信息
voidinsert_prio（PCB*q）;//在优先数算法中,将尚未完成的PCB按优先数顺序插入到就绪队列中；
voidprior_init（charchose）;//进程优先级法初始化将进程按优先级插入到就绪队列里
voidpriority（charchose）;//进程优先级算法总函数
voidinsert_rr（PCB*q）;//在轮转法中，将执行了一个时间片单位（为2），但尚未完成的进程的PCB，插到就绪队列的队尾；
voidroundrun_init（charchose）;//循环轮转法初始化将就绪队列保存为FIFO队列
voidroundrun（charchose）;//循环轮转法总算法
voidmain（）//主函数
{
charchose='';
while（（chose!
='e'）&&（chose!
='E'））
{
fflush（stdin）;
system（"cls"）;
/*printf（"\t\t\t两种进程调度算法的模拟\n\n"）;
printf（"\tP.进程优先级算法模拟\n\n"）;*/
printf（"\tR.循环轮转算法模拟\n\n"）;
printf（"\tE.退出程序\n\n"）;
printf（"\t请输入你的选择：
"）;
scanf（"%c",&chose）;
if（（chose!
='e'）&&（chose!
='E'））
{
system（"cls"）;
/*if（（chose=='P'）||（chose=='p'））
{
prior_init（chose）;
priority（chose）;
system（"cls"）;
}*/
/*else*/if（（chose=='r'）||（chose=='R'））
{
roundrun_init（chose）;
roundrun（chose）;
system（"cls"）;
}
}
}
printf（"\n\t\t使用！
！
！
\n"）;
}
voidfirstin（void）//调度就绪队列的第一个进程投入运行；
{
if（ready!
=NULL）
{
run=ready;
ready=ready->next;
run->state='R';
run->next=NULL;
}
else
{
run=NULL;
}
}
voidprint1（chara）//打印表头行信息
{
if（toupper（a）=='P'）
{
printf（"namecputimeneedtimeprioritystate\n"）;
}
else
{
printf（"namecputimeneedtimecountroundstate\n"）;
}
}
voidprint2（charchose,PCB*p）//打印每一行的状态信息
{
if（toupper（chose）=='P'）
{
printf（"%s\t%d\t%d\t%d\t%c\n",p->name,p->cputime,p->needtime,p->prio,p->state）;
}
else
{
printf（"%s\t%d\t%d\t%d\t%d\t%c\n",p->name,p->cputime,p->needtime,p->count,p->round,p->state）;
}
}
voidprint（charchose）//打印每执行一次算法后所有的进程的状态信息
{
PCB*p;
print1（chose）;
if（run!
=NULL）
{
print2（chose,run）;
}
p=ready;
while（p!
=NULL）
{
print2（chose,p）;
p=p->next;
}
p=finish;
while（p!
=NULL）
{
print2（chose,p）;
p=p->next;
}
}
voidinsert_prio（PCB*q）/*在优先数算法中,将尚未
完成的PCB按优先数顺序插入到就绪队列中；*/
{
PCB*p,*s,*r;/*p,r用来控制就绪队列滚动，S指向插入的队列*/
s=q;
p=ready;
r=p;
if（s->prio>ready->prio）//要插入的进程的优先级大于ready的优先级
{
s->next=ready;
ready=s;
}
else//要插入的进程的优先级不大于ready的优先级
{
while（p）
{
if（p->prio>=s->prio）
{
r=p;
p=p->next;
}
else
break;
}//找到要插入的位置
s->next=p;
r->next=s;
}
}
/*voidprior_init（charchose）/*进程优先级法初始化
将进程按优先级插入到就绪队列里
{
PCB*p;
inti,time;
charna[10];
ready=NULL;
finish=NULL;
run=NULL;
printf（"\t\t进程优先级算法模拟全过程\n\n"）;
printf（"输入进程的个数N:
\n"）;
scanf（"%d",&N）;
for（i=0;i{
p=（PCB*）malloc（sizeof（PCB））;
printf（"输入第%d个进程名\n",i+1）;
scanf（"%s",na）;
printf（"完成进程需要的时间片数\n"）;
scanf（"%d",&time）;
strcpy（p->name,na）;
p->cputime=0;
p->needtime=time;
p->state='W';
p->prio=50-time;//设置进程优先值初值
if（ready==NULL）
{
ready=p;
ready->next=NULL;
}
else
{
insert_prio（p）;
}
printf（"当前就绪队列的进程的信息\n"）;
print（chose）;
}
printf（"%d个进程已按优先级从高到低进到就绪队列中\n",N）;
printf（"按回车键开始模拟优先级算法.....\n"）;
fflush（stdin）;
getchar（）;
firstin（）;
}*/
/*voidpriority（charchose）//进程优先级算法总函数
{
inti=1;
while（run!
=NULL）
{
run->cputime+=1;
run->needtime-=1;
run->prio-=1;
if（run->needtime==0）
{
run->next=finish;
finish=run;
run->state='F';
run->prio=0;
run=NULL;
firstin（）;
}
else
{
if（（ready!
=NULL）&&（run->prioprio））
{
run->state='W';
insert_prio（run）;
run=NULL;
firstin（）;
}
}
printf（"第%d次执行优先级算法\n",i++）;
print（chose）;
if（run）
{
printf（"按回车键继续下一次优先级算法.....\n"）;
}
else
printf（"优先级算法模拟过程结束！
！
\n"）;
fflush（stdin）;
getchar（）;
}
}*/
voidinsert_rr（PCB*q）//在轮转法中，将执行了一个时间片单位（为2），
//但尚未完成的进程的PCB，插到就绪队列的队尾；
{
tail->next=q;
tail=q;
q->next=NULL;
}
voidroundrun_init（charchose）/*循环轮转法初始化
将就绪队列保存为FIFO队列*/
{
PCB*p;
inti,time;
charna[10];
ready=NULL;
finish=NULL;
run=NULL;
printf（"\t\t循环轮转算法模拟全过程\n\n"）;
printf（"输入进程的个数N:
\n"）;
scanf（"%d",&N）;
for（i=0;i{
p=（PCB*）malloc（sizeof（PCB））;
printf（"输入第%d个进程名\n",i+1）;
scanf（"%s",na）;
printf（"完成进程需要的时间片数\n"）;
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）
{
insert_rr（p）;
}
else
{
p->next=ready;
ready=p;
tail=p;
}
printf（"当前就绪队列的进程的信息\n"）;
print（chose）;
}
printf（"%d个进程已按FIFO进到就绪队列中\n",N）;
printf（"按回车键开始模循环轮转算法.....\n"）;
fflush（stdin）;
getchar（）;
run=ready;
ready=ready->next;
run->state='R';
}
voidroundrun（charchose）//循环轮转法总算法
{
inti=1;
while（run!
=NULL）
{
run->cputime+=1;
run->needtime-=1;
run->count+=1;
if（run->needtime==0）
{
run->next=finish;
finish=run;
run->state='F';
run->prio=0;
run=NULL;
if（ready!
=NULL）
{
firstin（）;
}
}
else
{
if（run->count==run->round）
{
run->count=0;
if（ready!
=NULL）
{
run->state='W';
insert_rr（run）;
firstin（）;
}
}
}
printf（"第%d次执行循环轮转算法\n",i++）;
print（chose）;
if（run）
{
printf（"按回车键继续下一次循环轮转算法.....\n"）;
}
else
printf（"循环轮转算法模拟过程结束！
！
\n"）;
fflush（stdin）;
getchar（）;
}
}
升级会员 