操作系统课程设计Word文档下载推荐.docx
《操作系统课程设计Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《操作系统课程设计Word文档下载推荐.docx（71页珍藏版）》请在冰点文库上搜索。
/****************函数声明*******************/
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算法
intm;
m=rand（）%100;
if（m==0）
m=1;
returnm;
}//随机数函数结束
3.4先到先服务（FCFS）模块
3.4.1功能
模拟进程的先到先服务调度算法，按照进程编号依次运行。
3.4.2数据结构
//先来先服务算法
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（）;
CPUtime=P1->
Alltime;
State=3;
%3d号进程运行完毕\n"
Pro_Id）;
//Sleep（1000+P1->
Alltime*10）;
P1=P1->
Next;
}//while
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调度算法**/
inti;
structProcess*P2,*P;
P=NULL;
for（i=0;
i<
n;
i++）
P2=Head;
m=get_mintime（P2）;
printf（"
\n在未完成的进程中%d号进程需要运行时间最短\n\n"
m）;
P=alert_sjf（P2,m）;
printall（P2）;
P->
CPUtime=P->
P=NULL;
getchar（）;
}
\n所有进程运行结束。
\n\n"
SJF算法演示完毕，谢谢使用\n"
}
/**获取进程最短时间**/
intget_mintime（structProcess*P1）
intk,m;
k=1001;
m=0;
if（k>
Alltime&
&
State!
=3）
{
k=P1->
m=P1->
Pro_Id;
}//if
P1=P1->
/**修改sjf算法状态**/
structProcess*P1,*P;
intk=0;
P1=P2;
while
（1）
{
if（P1->
Pro_Id==m）
{
P1->
P=P1;
k=1;
else
{
P1=P1->
}
if（k==1）
break;
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算法
/**优先级调度算法**/
structProcess*P1,*P2;
intkey=0;
%d\n"
n）;
key）;
while（key<
n）
m=get_maxpri（P2）;
//获取优先级最高的进程ID
alert_status（P1,m）;
//修改进程的运行状态等信息
if（printall（P2））
key++;
alert_pri（P1,m）;
//修改进程的优先级
//printf（"
所有进程已经全部结束！
！
"
key=0;
/**获取优先度最高的进程号**/
k=P1->
Priority;
m=P1->
while（P1->
Next!
if（k<
Next->
Priority）
/**修改进程的优先度**/
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
Priority-3;
}//else
if（P2->
Priority<
=0）
{
P2->
Priority=0;
State=3;
}//if
P2=P2->
}//修改进程优先度函数结束
/**修改进程的状态**/
//intstatus;
P2=P1;
while（P2!
P2->
State==1）
P2->
State=2;
}//else
}//修改进程状态结束
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时间片调度算法****/
structProcess*P2,*P1;
intm=n;
按任意键，继续演示......."
getchar（）;
while（P1!
if（P1->
P1->
printall（P2）;
printf（"
getchar（）;
P2=Head;
if（P1->
CPUtime+4<
Alltime）
P1->
CPUtime+4;
}
else
printf（"
%d号进程已经运行完毕!
!
m--;
}//else
}//while
if（m==0）
P1=Head;
时间片轮转算法演示结束，谢谢使用。
3.8主函数模块
3.8.1功能
用于程序与用户的交互操作，由用户选择模拟实验的算法，并执行相应的算法。
3.8.2数据结构
intmain（）
3.8.3算法
/***********主函数**************/
structProcess*Head,*P1;
inta;
intk=1;
//intm;
intn;
n=0;
while（k==1）
system（"
cls"
P1=NULL;
Head=NULL;
srand（（int）time（NULL））;
//该语句只需要一次递交种子就可以
**********************实验模拟开始**************************\n"
1.先到先服务调度算法;
2.SJF（最短作业优先）调度算法;
3.优先度调度算法;
4.RR（轮转法）调度算法;
5.退出;
*************************************************************\n"
请输入您的选择：
scanf（"
%d"
&
a）;
while（a!
=1&
a!
=2&
=3&
=4&
=5）
对不起，您的选择有误，请重新选择"
a）;
if（a==1||a==2||a==3||a==4）
P1=INITIAL（&
n）;
Head=P1;
printall（P1）;
初始化进程已完成.\n"
\n按任意键实验开始演示：
switch（a）
case1:
FCFS（Head）;
break;
case2:
SJF（Head,n）;
break;
case3:
Priority（Head,n）;
case4:
RR（Head,n）;
case5:
感谢您使用该系统.再见~~\n"
k=0;
}//switch
按任意键回到主菜单...."
}//main
3.9进程的初始化模块
3.9.1功能
用于由用户输入进程数以后，对进程的初始化，并利用随机函数，随机生成进程的优先度与alltime，并赋值。
3.9.2数据结构
structProcess*INITIAL（int*n）
3.9.3算法
/**进程的初始化**/
structProcess*P1,*Head,*P2;
inta=0;
inti=0;
P1=P2=Head=NULL;
/**进程的输入**/
do{
pleaseinputPCB_number（请输入进程数）:
scanf（"
}while（a==0）;
//do..while
/**/
P1=（structProcess*）malloc（sizeof（structProcess））;
Head=P1;
for（i=1;
i<
=a;
i++）
P1->
Pro_Id=i;
Priority=random_num（）;
CPUtime=0;
Alltime=random_num（）;
State=0;
if（i==a）
P2=（structProcess*）malloc（sizeof（structProcess））;
Next=P2;
P1=P2;
}//for
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循环。
修改后执行：
课题二:
系统动态分配资源模拟
1．设计目的
银行家算法是避免死锁的一种重要算法.通过编写一个模拟动态资源分配的银行家算法程序,进一步深入理解死锁产生思索的必要条件安全状态等重要概念,并掌握避免死锁的具体实施方法.
2.任务及要求
编程序模拟银行家算法,要求能体现算法的全过程
3.算法及数据结构
3.1算法的总体思想
银行家算法
设Requesti是进程Pi的请求向量,如果Requesti[j]=K,表示进程Pi需要K个Pj类型的资源.当Pi发出资源请求后,系统按下述步骤进行检查:
如果Requesti[j]<
=Need[i,j],便转向步骤2;
否则认为出错,因为它所需要的资源数已超出它所宣布的最大值.
=Available[i,j],便转向步骤3;
否则,表示尚无足够资源,Pi须等待.
系统试探着把资源分配给进程Pi,并修改下面数据结构中的数值:
Available[j]:
=Available[j]-Requesti[j];
Allocation[i,j]:
=Allocation[i,j]+Requesti[j]
Need[i,j]:
=Need[i,j]-Requesti[j];
系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态.若安全,才正式将资源分配给进程Pi,以完成本次分配;
否则,将本次的试探分配作废,恢复原来的资源分配状态,让进程Pi等待.
安全性算法
系统所执行的安全性算法可描述如下:
设置两个向量:
1工作向量Work:
它表示系统可提供给进程继续运行所需的各类资源数目,它含有m个元素,在执行安全算法开始时,Work:
=Available;
2Finish:
它表示系统是否有足够的资源分配给进程,
升级会员 