进程调度.docx
《进程调度.docx》由会员分享，可在线阅读，更多相关《进程调度.docx（27页珍藏版）》请在冰豆网上搜索。
进程调度
课题一：
进程调度模拟
1、设计目的
通过对进程调度算法的设计，深入理解进程调度的原理，同时掌握进程调度算法的实现方法和技巧。
2、任务及要求
1．用语言来实现对n个进程采用不同调度算法的进程调度。
2．每个用来标识进程的进程控制块PCB用结构来描述，包括以下字段：
（1）进程优先数ID，其中0为闲逛进程，用户进程的标识数为1，2，3…。
（2）进程优先级Priority，闲逛进程（idle）的优先级为0，用户进程的优先级大于0，且随机产生，优先数越大，优先级越高。
（3）进程占用的CPU时间CPUtime，进程每运行一次，累计值等于4。
（4）进程总共需要运行时间Alltime，利用随机函数产生。
（5）进程状态，0：
就绪态；1：
运行态；2：
阻塞态。
（6）队列指针next，用来将多个进程控制块PCB链接为队列。
3．优先数改变的原则
（1）进程在就绪队列中每呆一个时间片，优先数增加1。
（2）进程每运行一个时间片，优先数减3。
4．在调度前，系统中拥有的进程数PCB_number由键盘输入，经初始化后，所有的进程控制块PCB链接成就绪队列。
3、算法及数据结构
3.1算法的总体思想
先到先服务算法，给每个进程定一个进程号，然后按照进程号顺序进行即可。
最短作业优先算法要判断作业的alltime时间，alltime最小的最先执行，依次按照时间从小到大执行进程。
优先度调度算法，要先判断优先度的大小，优先度最大的先执行，进程运行完毕以后，按照优先数的改变的原则进行改变，然后继续判断所有的优先数的大小，依旧是优先数最大的先执行，直到执行完毕。
RR时间片轮转调度算法，要依次执行时间片用完即阻塞，转交给下一个进程执行，直到所有进程运行完。
3.2数据结构模块
3.2.1功能
进程的结构体声明与函数的声明
3.2.2数据结构
structProcess
{
intPro_Id;//进程编号ID
intPriority;//进程优先级，随机产生
intCPUtime;//进程占用的CPU时间CPUtime
intAlltime;//进程共需运行时间,随机产生
intState;//进程状态
structProcess*Next;
};
/****************函数声明*******************/
intrandom_num（）;//随机数字产生
structProcess*INITIAL（int*n）;//进程的初始化
intprintall（structProcess*P1）;//打印所有进程的具体信息
intget_maxpri（structProcess*P1）;//获取优先度最高的进程号
intget_mintime（structProcess*P1）;//获作业时间最短的进程号
voidalert_status（structProcess*P1,intm）;//修改进程的状态
voidalert_pri（structProcess*P1,intm）;//修改进程的优先度
voidFCFS（structProcess*Head）;//先来先服务算法
voidPriority（structProcess*Head,intn）;//优先级调度算法
structProcess*alert_sjf（structProcess*P2,intm）;//修改sjf算法状态
voidSJF（structProcess*Head,intn）;//SJF调度算法
voidRR（structProcess*Head,intn）;//RR时间片调度算法
3.3随机数字产生方法模块
3.3.1功能
随机产生数字，用于进程初始化时的优先度与alltime赋值
3.3.2数据结构
intrandom_num（）
3.3.3算法
intrandom_num（）
{
intm;
m=rand（）%100;
if（m==0）
m=1;
returnm;
}//随机数函数结束
3.4先到先服务（FCFS）模块
3.4.1功能
模拟进程的先到先服务调度算法，按照进程编号依次运行。
3.4.2数据结构
voidFCFS（structProcess*Head）;//先来先服务算法
printall（structProcess*Head）;//打印所有进程信息
3.4.3算法
voidFCFS（structProcess*Head）
{
structProcess*P1,*P2;
P1=Head;
while（P1!
=NULL）
{
P1->State=1;
//printf（"%3d\n",P1->State）;
P2=Head;
printall（P2）;
printf（"按任意键，继续演示.......\n"）;
getchar（）;
P1->CPUtime=P1->Alltime;
P1->State=3;
//printf（"%3d号进程运行完毕\n",P1->Pro_Id）;
//Sleep（1000+P1->Alltime*10）;
P1=P1->Next;
}//while
P2=Head;
printall（P2）;
printf（"演示结束，谢谢。
\n"）;
}//FCFS结束
3.5SJF（最短作业优先）调度算法模块
3.5.1功能
将每个进程与其下一个CPU区间段相关联。
当CPU为可用时，它会赋给具有最短后续CPU区间的进程。
如果两个进程具有同样长度的CPU区间，那么可以使用FCFS调度来处理。
3.5.2数据结构
voidSJF（structProcess*Head,intn）
intget_mintime（structProcess*P1）
structProcess*alert_sjf（structProcess*P2,intm）
3.5.3算法
/**SJF调度算法**/
voidSJF（structProcess*Head,intn）
{
intm;
inti;
structProcess*P2,*P;
P=NULL;
for（i=0;i{
P2=Head;
m=get_mintime（P2）;
printf（"\n在未完成的进程中%d号进程需要运行时间最短\n\n",m）;
P2=Head;
P=alert_sjf（P2,m）;
P2=Head;
printall（P2）;
P2=Head;
P->State=3;
P->CPUtime=P->Alltime;
P=NULL;
printf（"按任意键，继续演示.......\n"）;
getchar（）;
}
P2=Head;
printf（"\n所有进程运行结束。
\n\n"）;
printall（P2）;
printf（"SJF算法演示完毕，谢谢使用\n"）;
}
/**获取进程最短时间**/
intget_mintime（structProcess*P1）
{
intk,m;
k=1001;
m=0;
while（P1!
=NULL）
{
if（k>P1->Alltime&&P1->State!
=3）
{
k=P1->Alltime;
m=P1->Pro_Id;
}//if
P1=P1->Next;
}//while
returnm;
}
/**修改sjf算法状态**/
structProcess*alert_sjf（structProcess*P2,intm）
{
structProcess*P1,*P;
intk=0;
P1=P2;
P=NULL;
while
（1）
{
if（P1->Pro_Id==m）
{
P1->State=1;
P=P1;
k=1;
}//if
else
{
P1=P1->Next;
}
if（k==1）
break;
}//while
returnP;
}
3.6优先级调度算法模块
3.6.1功能
1.每个进程被赋予一个优先级数字（优先权）
2.CPU分配给优先权高的进程（优先级数字越小，则优先权越大）
3.6.2数据结构
voidPriority（structProcess*Head,intn）
intget_maxpri（structProcess*P1）
voidalert_pri（structProcess*P1,intm）
voidalert_status（structProcess*P1,intm）
3.6.3算法
/**优先级调度算法**/
voidPriority（structProcess*Head,intn）
{
structProcess*P1,*P2;
intkey=0;
intm;
P1=Head;
P2=Head;
//printf（"%d\n",n）;
//printf（"%d\n",key）;
while（key{
m=get_maxpri（P2）;//获取优先级最高的进程ID
//printf（"%d\n",m）;
alert_status（P1,m）;//修改进程的运行状态等信息
P2=Head;
if（printall（P2））
key++;
P1=Head;
alert_pri（P1,m）;//修改进程的优先级
printf（"按任意键，继续演示.......\n"）;
getchar（）;
//printf（"%d\n",key）;
}
printf（"所有进程已经全部结束！
！
！
"）;
key=0;
}
/**获取优先度最高的进程号**/
intget_maxpri（structProcess*P1）
{
intk,m;
k=P1->Priority;
m=P1->Pro_Id;
while（P1->Next!
=NULL）
{
if（kNext->Priority）
{
k=P1->Next->Priority;
m=P1->Next->Pro_Id;
}//if
P1=P1->Next;
}//while
returnm;
}
/**修改进程的优先度**/
voidalert_pri（structProcess*P1,intm）
{
structProcess*P2;
intk;
k=0;
P2=P1;
while（P2!
=NULL）
{
if（P2->Priority>0）
{
if（P2->Pro_Id!
=m）
{
P2->Priority=P2->Priority+1;
}//if
else
{
P2->Priority=P2->Priority-3;
}//else
if（P2->Priority<=0）
{
P2->Priority=0;
P2->State=3;
}//if
}//if
P2=P2->Next;
}//while
}//修改进程优先度函数结束
/**修改进程的状态**/
voidalert_status（structProcess*P1,intm）
{
structProcess*P2;
//intstatus;
P2=P1;
while（P2!
=NULL）
{
if（P2->Pro_Id==m）
{
P2->State=1;
}//if
else
{
if（P2->State==1）
P2->State=2;
}//else
P2=P2->Next;
}//while
}//修改进程状态结束
3.7时间片轮转调度算法模块
3.7.1功能
如果就绪队列中有n个进程，且时间片为q，则每个进程会得到1/n的CPU时间，每个长度不超过q时间单元。
每个进程必须等待CPU的时间不会超过（n-1）q个时间单元，直到它的下一个时间片为止
3.7.2数据结构
voidRR（structProcess*Head,intn）
3.7.3算法
/*****RR时间片调度算法****/
voidRR（structProcess*Head,intn）
{
structProcess*P2,*P1;
intm=n;
P2=Head;
printall（P2）;
printf（"按任意键，继续演示......."）;
getchar（）;
P2=Head;
P1=Head;
while
（1）
{
while（P1!
=NULL）
{
if（P1->State!
=3）
{
P1->State=1;
printall（P2）;
printf（"按任意键，继续演示.......\n"）;
getchar（）;
P2=Head;
if（P1->CPUtime+4Alltime）
{
P1->State=2;
P1->CPUtime=P1->CPUtime+4;
}
else
{
P1->CPUtime=P1->Alltime;
P1->State=3;
printf（"%d号进程已经运行完毕!
!
!
!
\n\n",P1->Pro_Id）;
m--;
}//else
}//if
P1=P1->Next;
}//while
if（m==0）
break;
else
P1=Head;
}
P2=Head;
printall（P2）;
printf（"时间片轮转算法演示结束，谢谢使用。
\n"）;
}
3.8主函数模块
3.8.1功能
用于程序与用户的交互操作，由用户选择模拟实验的算法，并执行相应的算法。
3.8.2数据结构
intmain（）
3.8.3算法
/***********主函数**************/
intmain（）
{
structProcess*Head,*P1;
inta;
intk=1;
//intm;
intn;
n=0;
while（k==1）
{
system（"cls"）;
P1=NULL;
Head=NULL;
srand（（int）time（NULL））;//该语句只需要一次递交种子就可以
printf（"**********************实验模拟开始**************************\n"）;
printf（"\n"）;
printf（"\n"）;
printf（"\n"）;
printf（"1.先到先服务调度算法;\n"）;
printf（"2.SJF（最短作业优先）调度算法;\n"）;
printf（"3.优先度调度算法;\n"）;
printf（"4.RR（轮转法）调度算法;\n"）;
printf（"5.退出;\n"）;
printf（"\n"）;
printf（"\n"）;
printf（"\n"）;
printf（"*************************************************************\n"）;
printf（"请输入您的选择：
"）;
scanf（"%d",&a）;
while（a!
=1&&a!
=2&&a!
=3&&a!
=4&&a!
=5）
{
printf（"对不起，您的选择有误，请重新选择"）;
scanf（"%d",a）;
}//while
if（a==1||a==2||a==3||a==4）
{
P1=INITIAL（&n）;
Head=P1;
printall（P1）;
printf（"初始化进程已完成.\n"）;
printf（"\n按任意键实验开始演示：
"）;
getchar（）;
getchar（）;
}
switch（a）
{
case1:
FCFS（Head）;
break;
case2:
SJF（Head,n）;
break;
case3:
Priority（Head,n）;
break;
case4:
RR（Head,n）;
break;
case5:
printf（"感谢您使用该系统.再见~~\n"）;
k=0;
break;
}//switch
printf（"\n"）;
printf（"\n"）;
printf（"\n"）;
if（a==1||a==2||a==3||a==4）
{
printf（"按任意键回到主菜单...."）;
getchar（）;
}
}//while
}//main
3.9进程的初始化模块
3.9.1功能
用于由用户输入进程数以后，对进程的初始化，并利用随机函数，随机生成进程的优先度与alltime，并赋值。
3.9.2数据结构
structProcess*INITIAL（int*n）
3.9.3算法
/**进程的初始化**/
structProcess*INITIAL（int*n）
{
structProcess*P1,*Head,*P2;
inta=0;
inti=0;
P1=P2=Head=NULL;
/**进程的输入**/
do{
printf（"pleaseinputPCB_number（请输入进程数）:
\n"）;
scanf（"%d",&a）;
}while（a==0）;//do..while
/**/
P1=（structProcess*）malloc（sizeof（structProcess））;
Head=P1;
for（i=1;i<=a;i++）
{
P1->Pro_Id=i;
P1->Priority=random_num（）;
P1->CPUtime=0;
P1->Alltime=random_num（）;
P1->State=0;
if（i==a）
{
break;
}
P2=（structProcess*）malloc（sizeof（structProcess））;
P1->Next=P2;
P1=P2;
}//for
P1->Next=NULL;
*n=a;
returnHead;
}//初始化函数结束
4、实验结果及分析
4.1实验结果
先到先服务算法演示：
SJF（最短作业优先）调度算法演示：
优先度调度算法演示：
RR（轮转法）调度算法演示：
4.2结果分析
1.intrandom_num（）这个函数导致随机数产生以后，所有的随机数都是一个数。
问题原因是:
随机种子是传递给操作系统的，不是传递给函数的，所以，不必多次调用。
在一个程序中，种子只产生一次即可。
也就是说:
srand（（int）time（NULL））;这句只出现在main函数里一次就可以
修改后运行结果：
2.进程开始执行以后当所有进程都结束后。
程序一直在运行，结束不了。
加入变量key表示已经完成的进程作为解决办法，但是当用指针处理的时候，发现打印出的是key的地址，但是用的是*key，最后只能用printall返回一个值表示有进程完成。
解决了问题，不明白为什么用*key不能打印出
数字而是地址
修改加入变量后结果是：
3.再次选择优先度算法时，运行输入一个进程的时候发现直接没有运行提示程序运行完毕
原因是第一次运行完成后，没有把key置0导致第二次运行的时候出现key==n，不执行while循环。
修改后执行：
升级会员 