操作系统-银行家算法实验报告文档格式.doc
《操作系统-银行家算法实验报告文档格式.doc》由会员分享，可在线阅读，更多相关《操作系统-银行家算法实验报告文档格式.doc（15页珍藏版）》请在冰豆网上搜索。
若安全，则分配，否则，不分配，恢复原来状态，拒绝申请。
二．算法分析
2.1银行家算法中的数据结构
为资源的种类i
进程的数量j
可利用资源向量intAvailable[j]
最大需求矩阵intMax[i][j]
分配矩阵intAllocation[i][j]
需求矩阵intneed[i][j]=Max[i][j]-Allocation[i][j]
申请各类资源数量intRequesti[j]i进程申请j资源的数量
工作向量intWork[x]intFinish[y]
2.2银行家算法
设Requesti是进程Pi的请求向量，如果Requesti[j]=K，表示进程Pi需要k个Rj类型的资源，当Pi发出资源请求后，系统按照下述步骤进行检查：
（1）如果Requesti[j]≤Need[j],便转向步骤
（2）；
否则认为出错，因为它所需要的资源数已经超过它所宣布的最大值。
（2）如果Requesti[j]≤Available[j]，便转向步骤（3）；
否则，表示尚无足够资源，Pi须等待。
（3）系统试探着将资源分配给进程Pi，并修改下面数据结构中的数值：
Available[j]:
=Available[j]-Requesti[j];
Allocation[i,j]:
=Allocation[i,j]+Requesti[j];
Need[i,j]:
=Need[i,j]-Requesti[j];
（4）系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。
若安全，才正式将资源分配给进程Pi，以完成本次分配；
否则本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。
2.3安全性检查算法（Check_safe（）函数）
（1）设置两个向量：
工作向量Work，它表示系统可提供给进程继续运行所需的各类资源数目，在执行安全性算法开始时，Work=Available。
Finish，它表示系统是否有足够的资源分配给进程，使之运行完成。
开始时先做Finish[i]=0；
当有足够的资源分配给进程时，再令Finish[i]=1。
（2）在进程中查找符合以下条件的进程：
条件1：
Finish[i]=0；
条件2：
need[i][j]<
=Work[j]
若找到，则执行步骤（3）否则，执行步骤（4）
（3）当进程获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：
Work[j]=Work[j]+Allocation[i][j]；
Finish[i]=1；
gotostep2；
（4）如果所有的Finish[i]=1都满足，则表示系统处于安全状态，否则，处于不安全状态。
三、算法设计
初始化算法流程图：
银行家算法流程图：
（1）采用动态输入的方法对进程个数Pnum，资源种类数Stype,资源总数Ssum[],最大需求Max[][],已分配Allocation[][]进行初始化；
（2）根据已输入数据计算出需求矩阵Need[][],可用资源数Available[];
（3）利用Check_safe（）函数对此刻系统的安全性进行检测，如果安全，给出安全序列；
（4）进程i提出资源请求，利用Ask_Distribution（）函数检测请求是否合理；
合理则满足请求，并给出安全序列；
不合理则给出错误提示；
（5）做出开始界面、选择界面、退出界面，使程序美观、易操作；
四、编码实现（实验的java代码）
importjava.util.Scanner;
publicclassYinHang{
Scannerin=newScanner（System.in）;
intPnum;
//进程个数
intStype;
//资源种类数
int[]Ssum;
//各类资源总数
int[][]Max;
//最大需求矩阵
int[][]Allocation;
//已分配矩阵
int[][]Need;
//需求矩阵
int[]Available;
//可用资源数
int[]Work;
//Available的试分配向量
boolean[]Finish=newboolean[50];
//试分配结果标识向量
publicYinHang（）{
start（）;
}
publicvoidstart（）{
System.out
.println（"
***********************************************************"
）;
欢迎使用银行家算法"
120607124罗巾英"
System.out.println（"
请选择操作：
\n\t1.开始使用\n\t2.退出"
inta;
a=in.nextInt（）;
if（a==1）{
input（）;
}else{
quit（）;
}
publicvoidinput（）{
请输入T0时刻进程个数Pnum：
"
this.Pnum=in.nextInt（）;
请输入资源种类数Stype:
this.Stype=in.nextInt（）;
this.Ssum=getSsum（）;
this.Max=getMax（）;
this.Allocation=getAllocation（）;
this.Need=getNeed（）;
this.Available=getAvailable（Pnum,Stype）;
该时刻的资源分配表：
output（）;
this.Check_Safe（Available）;
this.Ask_Distribution（false）;
publicint[]getSsum（）{
Ssum=newint[Stype];
请输入各类资源总数Ssum:
for（inti=0;
i<
Stype;
i++）{
Ssum[i]=in.nextInt（）;
returnSsum;
publicint[][]getMax（）{
Max=newint[Pnum][Stype];
请输入最大需求矩阵Max:
Pnum;
for（intj=0;
j<
j++）{
Max[i][j]=in.nextInt（）;
}
returnMax;
publicint[][]getAllocation（）{
Allocation=newint[Pnum][Stype];
请输入已分配资源情况矩阵Allocation"
Allocation[i][j]=in.nextInt（）;
returnAllocation;
publicint[][]getNeed（）{
Need=newint[Pnum][Stype];
Need[i][j]=Max[i][j]-Allocation[i][j];
returnNeed;
publicint[]getAvailable（intx,inty）{
Available=newint[Stype];
Available=Ssum;
进程的可用资源Available为：
for（intj=0;
for（inti=0;
Available[j]=Available[j]-Allocation[i][j];
System.out.print（Available[j]+"
"
returnAvailable;
publicvoidsetFinish（intx）{
Finish[i]=false;
publicbooleanCheck_Safe（intavail[]）{
booleanboo=false;
intk[]=newint[Pnum];
inta=0;
Work=newint[Stype];
avail.length;
Work[i]=avail[i];
setFinish（
升级会员 