银行家算法调度算法多线程源代码流程图实验报告.docx
《银行家算法调度算法多线程源代码流程图实验报告.docx》由会员分享，可在线阅读，更多相关《银行家算法调度算法多线程源代码流程图实验报告.docx（30页珍藏版）》请在冰豆网上搜索。
银行家算法调度算法多线程源代码流程图实验报告
课程设计报告
（2013--2014年度第1学期）
名称：
操作系统原理课程设计
院系：
班级：
学号：
学生姓名：
指导教师：
设计周数：
1
成绩：
日期：
2013年11月15日
《操作系统原理课程设计B》课程设计
任务书
一、目的与要求
1.理解和掌握操作系统的基本概念、基本组成与工作原理；
2.理解和掌握操作系统中主要功能模块的工作原理及其实现算法；
3.掌握软件模块设计技能；熟悉并能较好地利用软件开发环境独立编程、调试和分
析程序运行情况，逐渐形成创新思维和从事系统软件的研究和开发能力。
二、主要内容
采用某种程序设计语言，设计与开发一个仿真操作系统，要求具备进程调度、存储器管理、文件及设备管理等基本功能，具体内容包括：
1.模拟单处理器系统的进程调度，加深对进程的概念及进程调度算法的理解；
2.编写一个多线程程序，加深对现代操作系统中线程的理解；
3.编写和调试一个银行家算法程序，加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法；
4.用可变分区算法模拟主存的分配和回收，加深对存储器管理的理解，熟悉各种主存分配方法；
根据个人情况选做其中三个。
三、进度计划
序号
设计（实验）内容
完成时间
备注
1
熟悉开发环境及程序设计语言
1天
2
系统的分析、设计
2天
3
调试与集成
1天
4
验收，提交实验报告
1天
四、设计（实验）成果要求
至少完成主要内容中的3项，统一使用课程设计报告书，文字清楚、工整。
学生姓名：
指导教师：
2013年11月15日
一、课程设计（综合实验）的目的与要求
1.理解和掌握操作系统的基本概念、基本组成与工作原理；
2.理解和掌握操作系统中主要功能模块的工作原理及其实现算法；
3.掌握软件模块设计技能；熟悉并能较好地利用软件开发环境独立编程、调试和分
析程序运行情况，逐渐形成创新思维和从事系统软件的研究和开发能力。
二、实验环境
VisualC++6.0和JCreator
三、设计（实验）正文
多线程：
用Runnable接口和继承Thread类的方法实现多线程程序。
设计龟兔赛跑，赛程1000米，兔子跑5米，乌龟跑1米，兔子每20米休息500毫秒，乌龟每100米休息500毫秒。
谁先到终点就结束程序，并显示获胜方。
调度算法：
编程实现先来先服务和短作业优先调度算法。
先来先服务算法是每次调度从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。
该进程一直运行到完成或发生某件事而阻塞后才放弃处理机。
短作业优先算法是从后备队列中选择一个或若干个估计时间最短的作业，将他们调入内存运行。
程序要求
进程个数n；每个进程的到达时间T1,…,Tn和服务时间S1,…,Sn；选择算法1-FCFS，2-SJF。
要求采用先来先服务FCFS和短作业优先SJF分别调度进程运行，计算每个进程的周转时间，带权周转时间，并且计算所有进程的平均周转时间，带权平均周转时间；
要求输出计算出来的每个进程的周转时间，带权周转时间，所有进程的平均周转时间，带权平均周转时间。
银行家：
2.算法数据结构
1）可利用资源向量Available，它是一个最多含有100个元素的数组，其中的每一个元素代表一类可利用的资源的数目，其初始值是系统中所配置的该类全部可用资源数目。
其数值随该类资源的分配和回收而动态地改变。
如果Available（j）=k，标是系统中现有j类资源k个。
2）最大需求矩阵Max，这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。
如果Max（i，j）=k，表示进程i需要j类资源的最大数目为k。
3）分配矩阵Allocation，这也是一个n×m的矩阵，它定义了系统中的每类资源当前一分配到每一个进程的资源数。
如果Allocation（i，j）=k，表示进程i当前已经分到j类资源的数目为k。
Allocation i表示进程i的分配向量，有矩阵Allocation的第i行构成。
4）需求矩阵Need，这还是一个n×m的矩阵，用以表示每个进程还需要的各类资源的数目。
如果Need（i，j）=k，表示进程i还需要j类资源k个，才能完成其任务。
Need i表示进程i的需求向量，由矩阵Need的第i行构成。
5）上述三个矩阵间存在关系：
Need（i，j）=Max（i，j）-Allocation（i，j）；
3.银行家算法
设Request[i]是进程i的请求向量，如果Request[i，j]=K,表示进程i需要K个j类型的资源。
当i发出资源请求后，系统按下述步骤进行检查：
1）如果Request i ≤Need，则转向步骤2；否则，认为出错，因为它所请求的资源数已超过它当前的最大需求量。
2）如果Request i ≤Available，则转向步骤3；否则，表示系统中尚无足够的资源满足i的申请，i必须等待。
3）系统试探性地把资源分配给进程i，并修改下面数据结构中的数值：
Available = Available -Request i
Allocation i= Allocation i+Request i
Need i=Need i -Request i
4）系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。
如果安全才正式将资源分配给进程i，以完成本次分配；否则，将试探分配作废，恢复原来的资源分配状态，让进程i等待。
四、课程设计（综合实验）总结或结论
通过本次实验，基本了解了线程的概念，作用，方法以及使用规则。
也了解到run方法所包含的代码就是和其他线程同时运行的代码以达到同一时刻运行多段代码的目的。
当终止了run以后。
这个线程也就结束了。
调用线程的start方法才会执行run方法。
对调度算法特别是FCFS和SJF有了更深的理解，而且锻炼了我的思维能力，
使我能更全面地思考问题，以后还需要多做些这方面的练习。
对于银行家算法也更深刻的知道银行家算法是避免死锁的一种重要方法，通过编写一个简单的银行家算法程序，加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
死锁的产生，必须同时满足四个条件，即一个资源每次只能由一个进程；第二个为等待条件，即一个进程请求资源不能满足时，它必须等待，但它仍继续保持已得到的所有其他资源；第三个为非剥夺条件，即在出现死锁的系统中一定有不可剥夺使用的资源；第四个为循环等待条件，系统中存在若干个循环等待的进程，即其中每一个进程分别等待它前一个进程所持有的资源。
防止死锁的机构只能确保上述四个条件之一不出现，则系统就不会发生死锁。
总体上此次实验锻炼了自己的耐心。
写程序重要的品质就应该是耐心了，如果没有了耐心是写不出程序的，出现了错误稍微长一点时间调试不出就放弃，你永远无法写出程序。
写程序切记，戒骄戒躁。
极大的调高了自己编程的能力。
每一条程序自己都要读懂，每一处错误自己都要亲手调通，这个过程是看书得不到的。
编程要的就是一种感觉，亲自动手去写才能培养这种感觉。
五、参考文献
汤子赢操作系统西安电子科技大学出版社,第三版.出版日期
张白一，崔尚森，面向对象程序设计—Java（第二版），西安电子科技大学出版社
附录（设计流程图、程序、表格、数据等）
多线程：
[java]
源代码：
importjava.util.Date;
publicclassTestextendsThread{
privateinttortoise_walk=0;//乌龟已跑长度存放变量
privateintrabbit_walk=0;//兔子已跑长度存放变量
privateintfinish=200;//终点
privatevolatilebooleanhasWinner=false;//胜利者诞生
classTortoise_RunimplementsRunnable{
@Override
publicvoidrun（）{
try{
while（!
hasWinner）{
if（tortoise_walk%100==0&&（tortoise_walk!
=0||tortoise_walk>=finish））{//乌龟每100米休息500毫秒
System.out.println（"乌龟休息中………………"）;
Thread.sleep（500）;
}
tortoise_walk++;
System.out.println（"乌龟已跑"+tortoise_walk+"米"）;
}
}catch（InterruptedExceptione）{
e.printStackTrace（）;
}
}
}
classRabbit_RunimplementsRunnable{
@Override
publicvoidrun（）{
try{
while（!
hasWinner）{
if（rabbit_walk%20==0&&（rabbit_walk!
=0||rabbit_walk>=finish））{//兔子每20米休息500毫秒
System.out.println（"兔子休息中………………"）;
Thread.sleep（500）;
}
rabbit_walk=rabbit_walk+5;//每秒跑5步
System.out.println（"兔子已跑"+rabbit_walk+"米"）;
}
}catch（InterruptedExceptione）{
e.printStackTrace（）;
}
}
}
publicvoidrun（）{
newThread（newRabbit_Run（））.start（）;
newThread（newTortoise_Run（））.start（）;
}
publicstaticvoidmain（String[]args）throwsException{
longtemp_actionTime=System.currentTimeMillis（）;
System.out.println（"比赛开始：
"+newDate（temp_actionTime）+"毫秒"）;
Testt=newTest（）;
newThread（t）.start（）;
while（true）{
if（t.tortoise_walk>=t.finish||t.rabbit_walk>=t.finish）{
t.hasWinner=true;
break;
}
}
StringwinnnerName=t.tortoise_walk>t.rabbit_walk?
"乌龟":
"兔子";
longtemp_lastTime=System.currentTimeMillis（）;
System.out.println（winnnerName+"胜利"）;
System.out.println（"比赛结束：
"+newDate（temp_lastTime）+"毫秒"）;
System.out.println（"所耗时间：
"+（temp_lastTime-temp_actionTime）+"毫秒"）;
System.out.println（"兔子="+t.rabbit_walk+"乌龟="+t.tortoise_walk）;
}
}
调度算法：
FCFS流程图
SJF流程图：
源代码：
#include"stdio.h"
#include"stdlib.h"
#include"string.h"
#defineM50
structsjf{
intjobnumber;
floatsubmittime;
floatruntime;
floatstarttime;
floatfinishtime;
floatwaittime;
floatturnaroundtime;
}temp;
staticstructsjfst[M];
voidinput（structsjf*p,intN）
{
inti;
printf（"Pleaseinputthejobnumber,submittimeandruntime:
\nForexmple:
18.52.0\n"）;
for（i=0;i{
scanf（"%d%f%f",&p[i].jobnumber,&p[i].submittime,&p[i].runtime）;
}
}
voidprint（structsjf*p,intN）
{
intk;
floath,g;
printf（"runorder:
"）;
printf（"%d",p[0].jobnumber）;
for（k=1;kprintf（"-->%d",p[k].jobnumber）;
printf（"\nTheprocess'sinformation:
\n"）;
printf（"\njobnum\tsubmit\trun\tstart\tfinal\twait\tturnaround\n"）;
for（k=0;k{
h+=p[k].turnaroundtime;
printf（"%d\t%-.1f\t%-.1f\t%-.1f\t%-.1f\t%-.1f\t%-.1f\t\n",p[k].jobnumber,p[k].submittime,p[k].runtime,p[k].starttime,p[k].finishtime,p[k].waittime,p[k].turnaroundtime）;
}
g=h/N;
printf（"\nTheaverageturnaroundtimeis%-.2f\n",g）;
}
/*按提交时间从小到大排序*/
voidsort1（structsjf*p,intN）
{
inti,j;
for（i=0;ifor（j=0;j<=i;j++）
if（p[i].submittime{
temp=p[i];
p[i]=p[j];
p[j]=temp;
}
}
/*运行*/
voiddeal（structsjf*p,intN）
{
intk;
for（k=0;k{
if（k==0）
{
p[k].starttime=p[k].submittime;
p[k].finishtime=p[k].submittime+p[k].runtime;
}
else
{
if（p[k].submittime>p[k-1].finishtime）
{
p[k].starttime=p[k].submittime;
p[k].finishtime=p[k].submittime+p[k].runtime;
}
else
{
p[k].starttime=p[k-1].finishtime;
p[k].finishtime=p[k-1].finishtime+p[k].runtime;
}
}
}
for（k=0;k{
p[k].turnaroundtime=p[k].finishtime-p[k].submittime;
p[k].waittime=p[k].starttime-p[k].submittime;
}
}
voidsort2（structsjf*p,intN）
{
intnext,m,n,k,i;
floatmin;
sort1（p,N）;
for（m=0;m{
i=0;
if（m==0）
p[m].finishtime=p[m].submittime+p[m].runtime;
else
{
if（p[m].submittime>p[m-1].finishtime）
{
p[m].finishtime=p[m].submittime+p[m].runtime;
}
else
p[m].finishtime=p[m-1].finishtime+p[m].runtime;
}
for（n=m+1;n{
if（p[n].submittime<=p[m].finishtime）/*判断内存中每次完成之后又多少到达的进程*/
i++;
}
min=p[m+1].runtime;
next=m+1;
for（k=m+1;k{
if（p[k+1].runtime{
min=p[k+1].runtime;
next=k+1;
}
}
temp=p[m+1];
p[m+1]=p[next];
p[next]=temp;
}
deal（p,N）;
print（p,N）;
}
voidmain（）
{
intN,i;
printf（"Pleaseinputthetotalnumberofjobs:
"）;
scanf（"%d",&N）;
input（st,N）;
loop2:
printf（"Whatkindofalgorithmdoyouwant?
Pleaseinput1toselectFCFS,or2toselectSJFor0toexit:
"）;
loop:
scanf（"%d",&i）;
if（i==0）
exit
（1）;
elseif（i==1）
{
sort1（st,N）;
deal（st,N）;
print（st,N）;
gotoloop2;
}
elseif（i==2）
{
sort2（st,N）;
gotoloop2;
}
else
{
printf（"Youhaveinputawrongnumber,pleaseinputagain:
"）;
gotoloop;
}
}
银行家算法：
流程图
源代码：
#include
#include
#include
#defineFalse0
#defineTrue1
usingnamespacestd;
intMax[100][100]={0};//各进程所需各类资源的最大需求
intAvaliable[100]={0};//系统可用资源
charname[100]={0};//资源的名称
intAllocation[100][100]={0};//系统已分配资源
intNeed[100][100]={0};//还需要资源
intRequest[100]={0};//请求资源向量
inttemp[100]={0};//存放安全序列
intWork[100]={0};//存放系统可提供资源
intM=100;//进程的最大数为
intN=100;//资源的最大数为
voidshowdata（）//显示资源矩阵
{
inti,j;
cout<<"系统目前可用的资源[Avaliable]:
"<for（i=0;icout<cout<for（j=0;jcout<cout<cout<<"MaxAllocationNeed"<cout<<"进程名";
for（j=0;j<3;j++）{
for（i=0;icout<cout<<"";
}
cout<for（i=0;icout<<""<for（j=0;jcout<cout<<"";
for（j=0;jcout<cout<<"";
for（j=0;jcout<cout<}
}
intchangdata（inti）//进行资源分配
{
intj;
for（j=0;jAvaliable[j]=Avaliable[j]-Request[j];
Allocation[i][j]=Allocation[i][j]+Request[j];
Need[i][j]=Need[i][j]-Request[j];
}
return1;
}
intsafe（）//安全性算法
{
inti,k=0,m,apply,Finish[100]={0};
intj;
for（j=0;j{Work[j]=Avaliable[j];}
for（i=0;iapply=0;
for（j=0;jif（Finish[i]==False&&Need[i][j]<=Work[j]）{
apply++;
if（apply==N）{
for（m=0;mWork[m]=Work[m]+Allocation[i][m];//变分配数
Finish[i]=True;
temp[k]=i;
i=-1;
k++;
}
}
}
}
for（i=0;iif（Finish[i]==False）{
cout<<"系统不安全"<return1;
}
}
cout<<"系统是安
升级会员 