银行家算法实验报告Word格式.docx
《银行家算法实验报告Word格式.docx》由会员分享，可在线阅读，更多相关《银行家算法实验报告Word格式.docx（20页珍藏版）》请在冰豆网上搜索。
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等待。
3.数据结构
1.可利用资源向量AVAILABLE。
这是一个含有M个元素的数组，其中的每一个元素代表一类可利用的资源数目，其3初始值是系统中所配置的该类全部可哦那个资源的数目，其数值随该类资源的分配和回收而动态的改变。
2.最大需求矩阵MAX。
这是一个M*N的矩阵，它定义了系统中N个进程中的每一个进程对M类资源的最大需求。
3.分配矩阵ALLOCATION。
这也是一个M*N的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。
4.需求矩阵NEED。
这也是一个M*N的矩阵，用以表示每一个进程尚需的各类资源数。
5.NEED[R,W]=MAX[R,W]-ALLOCATION[R,W]
4.主要函数说明
主要的常量变量
finalintP=10最大进程数
finalintR=5最大资源种类数
intAvailable[]可利用资源向量
intMax[][]最大需求矩阵
intAllocation[][]分配矩阵
intNeed[][]需求矩阵
intRequest1[]进程请求向量
intAllcount[]各资源总数
intC[]安全序列
主要模块
voidmain（）主函数
intSafe（）安全算法
voidSafe2（）安全序列输出
voidShow（）显示函数
voidWait（）等待进程
voidRequest（）进程分配
5.算法流程图
实验结果
结果分析
银行家算法就是当接收到一个系统资源的分配后找到一个安全序列，使得进程间不会发生死锁，若发生死锁则让进程等待。
实验总结:
通过本次实验，使我更好的理解了课本的知识。
能熟练使用编程程序完成实验，加深了对银行家算法的理解及应用。
实验中遇到一些问题，但是通过上网查阅资料，与同学之间的交流讨论顺利的解决。
通过这次的实践，使我的理论知识与实践更好的结合。
附录
程序源码:
importjava.io.*;
publicclassanquan
{
publicstaticvoidmain（Stringargs[]）
{
Testts=newTest（）;
ts.Putout（）;
System.out.println（）;
for（;
;
）
{
if（ts.Safe（）==1）
{
ts.Safe2（）;
ts.Show（）;
ts.Request（）;
}
}
}
}
classTest
finalintP=10;
//最大进程数
finalintR=5;
//最大资源种类数
inti,j,dd,tt;
intAvailable[];
//可利用资源向量
intMax[][];
//最大需求矩阵
intAllocation[][];
//分配矩阵
intNeed[][];
//需求矩阵
intRequest1[];
//进程请求向量
intAllcount[];
//各资源总数
intC[];
//安全序列
publicvoidPutout（）//提示
try{
do{
System.out.print（"
请输入进程数="
）;
BufferedReaderbr=newBufferedReader（newInputStreamReader（System.in））;
Strings=br.readLine（）;
i=Integer.parseInt（s）;
if（i<
=0||i>
P）
{
System.out.println（"
输入错误！
请输入10以内的正整数！
"
}
}while（i<
P）;
}catch（IOExceptione）{}
System.out.println（）;
try{
请输入资源种类数="
j=Integer.parseInt（s）;
if（j<
=0||j>
R）
请输入5以内的正整数！
}while（j<
System.out.println（"
请依次输入各种资源总数量：
System.out.println（）;
Allcount=newint[j];
for（intt=0;
t<
j;
t++）
try{
资源"
+t+"
:
Allcount[t]=Integer.parseInt（s）;
System.out.println（）;
请依次输入各进程所需要最大资源数量，即设置最大需求矩阵Max：
Max=newint[i][j];
i;
System.out.println（"
P"
for（intt1=0;
t1<
t1++）
+t1+"
Max[t][t1]=Integer.parseInt（s）;
if（Max[t][t1]>
Allcount[t1]）
输入的最大资源数超过了声明的该资源总数！
请重新输入！
}while（Max[t][t1]>
Allcount[t1]）;
请依次输入各进程已经占据各类资源数量，即设置分配矩阵Allocation：
Allocation=newint[i][j];
Allocation[t][t1]=Integer.parseInt（s）;
if（Allocation[t][t1]>
Max[t][t1]）
输入的已占有资源数超过了声明的最大资源数！
}while（Allocation[t][t1]>
Max[t][t1]）;
Need=newint[i][j];
for（intt=0;
for（intt1=0;
Need[t][t1]=Max[t][t1]-Allocation[t][t1];
Available=newint[j];
for（intt1=0;
intp1=Allcount[t1];
p1=p1-Allocation[t][t1];
Available[t1]=p1;
if（Available[t1]<
0）
Available[t1]=0;
publicintSafe（）//安全算法
{
intWork[]=newint[j];
{Work[t]=Available[t];
}
intFinish[]=newint[i];
{Finish[t]=0;
}
intC[]=newint[i];
intaa=0;
for（intk=0;
k<
k++）
intcount1=0;
if（Finish[t1]==0）
for（intt2=0;
t2<
t2++）
{
if（Need[t1][t2]>
Work[t2]）
{
break;
}
else
count1=count1+1;
}
if（count1==j）
Finish[t1]=1;
for（intt3=0;
t3<
t3++）
Work[t3]=Work[t3]+Allocation[t1][t3];
aa++;
if（aa==i）
return1;
else
return0;
publicvoidSafe2（）//安全序列输出
inta=0;
C[a++]=t1;
if（a==i）
系统安全，存在安全序列：
for（intt1=0;
+C[t1]+"
"
System.out.println（"
系统不安全"
publicvoidShow（）
当前各种资源的总数量为:
System.out.print（"
+"
+Allcount[t]+"
当前系统中各种资源可用数量，即Available为:
+Available[t]+"
资源"
Max"
Allocation"
Need"
进程"
===================================================="
for（intt=0;
t++）
{
P"
for（intt1=0;
System.out.print（Max[t][t1]+"
System.out.print（"
System.out.print（Allocation[t][t1]+"
System.out.print（Need[t][t1]+"
}
System.out.println（"
publicvoidWait（intss）
intsss=ss;
进程P"
+sss+"
等待,返回"
publicvoidRequest（）
是否需要请求资源：
是
（1）or否（0）"
do
tt=Integer.parseInt（br.readLine（））;
if（tt<
0||tt>
1）
输入错误，重新输入：
}while（tt<
1）;
if（tt==1）
intRequest1[]=newint[j];
请输入需要修改的进程P="
do
dd=Integer.parseInt（br.readLine（））;
if（dd<
0||dd>
i）
}while（dd<
i）;
请输入依次输入请求资源数量：
intcount2=0;
资源"
="
Request1[t1]=Integer.parseInt（br.readLine（））;
if（Request1[t1]>
Need[dd][t1]）
System.out.print（"
else
if（Request1[t1]>
Available[t1]）
count2=count2+1;
}while（Request1[t1]>
Need[dd][t1]）;
if（count2==0）
Available[t1]=Available[t1]-Request1[t1];
Allocation[dd][t1]=Allocation[dd][t1]+Request1[t1];
Need[dd][t1]=Need[dd][t1]-Request1[t1];
if（count2>
Wait（dd）;
if（count2==0）
if（Safe（）==0）
不予分配资源,返回"
Available[t1]=Available[t1]+Request1[t1];
Allocation[dd][t1]=Allocation[dd][t1]-Request1[t1];
Need[dd][t1]=Need[dd][t1]+Request1[t1];
if（tt==0）
Bye"
System.exit（0）;
}}
升级会员 