Java语言的银行家算法Word文档格式.docx
《Java语言的银行家算法Word文档格式.docx》由会员分享，可在线阅读，更多相关《Java语言的银行家算法Word文档格式.docx（12页珍藏版）》请在冰豆网上搜索。
（标题2，即三号黑体加粗）
银行家算法模拟。
二、设计目的：
通过此课程设计，进行的一次全面的综合训练，使之更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解，加强学生的动手能力。
三、总体设计思想概述：
安全状态下系统不会进入死锁，不安全状态可能进入死锁。
在进行资源分配之前，先计算分配的安全性，判断是否为安全状态。
四、设计要求：
银行家算法是避免死锁的一种重要方法，本实验要求用高级语言编写和调试一个简单的银行家算法程序。
加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
设计完成后，要求写出一份详细的设计报告。
五、设计方案：
编制银行家算法通用程序，并检测所给状态的系统安全性。
1）银行家算法中的数据结构
假设有n个进程m类资源，则有如下数据结构：
可利用资源向量Available。
这是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态地改变。
Available[j]=K，则表示系统中现有Rj类资源K个。
最大需求矩阵Max。
这是一个n*m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。
如果Max[i，j]=K，则表示进程i需要Rj类资源的最大数目为K。
分配矩阵Allocation。
这也是一个n*m的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。
如果Allocation[i，j]=K，则表示进程i当前已分得Rj类资源的数目为K。
需求矩阵Need。
这也是一个n*m的矩阵，用以表示每一个进程尚需的各类资源数。
如果Need[i,j]=K，则表示进程i还需要Rj类资源K个，方能完成其任务。
上述三个矩阵存在如下关系：
Need[i,j]=Max[i，j]-Allocation[i，j]
2）银行家算法
设进程I提出请求Request[N]，则银行家算法按如下规则进行判断。
（1）如果Request[N]<
=NEED[I，N]，则转
（2）；
否则，出错。
（2）如果Request[N]<
=AVAILABLE，则转（3）；
（3）系统试探分配资源，修改相关数据：
AVAILABLE=AVAILABLE-REQUEST
ALLOCATION=ALLOCATION+REQUEST
NEED=NEED-REQUEST
（4）系统执行安全性检查，如安全，则分配成立；
否则试探险性分配作废，系统恢复原状，进程等待。
3）安全性检查
（1）设置两个工作向量WORK=AVAILABLE；
FINISH[M]=FALSE
（2）从进程集合中找到一个满足下述条件的进程，
FINISH[i]=FALSE
NEED<
=WORK
如找到，执行（3）；
否则，执行（4）
（3）设进程获得资源，可顺利执行，直至完成，从而释放资源。
WORK=WORK+ALLOCATION
FINISH=TRUE
GOTO2
（4）如所有的进程Finish[M]=true，则表示安全；
否则系统不安全。
六、说明
通过程序实现定义的进程，为各进程分配资源，具体过程是：
首先在程序中定义了3类资源，数量分别为10，5，7。
然后定义进程p0，p1，p2，p3，p4，接着为各进程申请各资源，然后在程序执行并比较申请的资源数量与各资源所剩数量，若前者大于后者则申请失败，反之则成功。
同时该程序可以撤消新建进程，也可以查看资源分配情况。
七、流程图：
八、运行结果
9、源程序
publicclassBanker{
publicfinalstaticintN=5;
//?
?
publicfinalstaticintM=3;
privateintResource[]=newint[M];
privateintAvailable[]=newint[M];
privateintMax[][]=newint[N][M];
privateintAllocation[][]=newint[N][M];
privateintNeed[][]=newint[N][M];
privateintWork[]=newint[M];
?
privatebooleanFinish[]=newboolean[N];
privateintRequest[]=newint[M];
privateintp[]=newint[N];
publicBanker（int_Resource[],int_Available[],int_Max[][],
int_Allocation[][]）{//?
System.arraycopy（_Resource,0,Resource,0,Resource.length）;
System.arraycopy（_Available,0,Available,0,Available.length）;
System.arraycopy（_Max,0,Max,0,Max.length）;
System.arraycopy（_Allocation,0,Allocation,0,Allocation.length）;
for（inti=0;
i<
Need.length;
i++）{//?
Need?
for（intj=0;
j<
Need[i].length;
j++）
Need[i][j]=Max[i][j]-Allocation[i][j];
}
Finish.length;
i++）
//?
Finish?
Request?
Finish[i]=false;
Request.length;
Request[i]=0;
System.arraycopy（Request,0,Work,0,Work.length）;
Work
p.length;
p[i]=0;
show（）;
if（safe（））{//?
System.out.println（"
\n?
!
"
）;
:
N;
j++）{
if（j==N-1）
System.out.print（"
+p[j]）;
else
+p[j]+"
——>
}
\n"
}
publicvoidbank（intk,int_Request[]）
throwsArrayIndexOutOfBoundsException{//?
System.arraycopy（_Request,0,Request,0,Request.length）;
inti;
for（i=0;
i++）{
if（Request[i]>
Need[k][i]）{//?
k?
System.out.println（"
+k+"
+i+"
+Request[i]
+"
+"
+Need[k][i]）;
break;
Available[i]）{//?
+Available[i]）;
if（i==Request.length）{
M;
//?
System.out.print（"
+j+"
+Request[j]
j++）{//?
Available[j]=Available[j]-Request[j];
Allocation[k][j]=Allocation[k][j]+Request[j];
Need[k][j]=Need[k][j]-Request[j];
if（!
safe（））{//?
recover（k）;
show（）;
}else{//?
for（intj=0;
if（j==N-1）
System.out.print（"
else
}
publicbooleansafe（）{//?
System.arraycopy（Available,0,Work,0,Work.length）;
Available?
false
intn=0;
if（Finish[i]==false）{//?
Finish[i]==0?
intcounter=0;
if（Need[i][j]<
=Work[j]）
counter++;
if（counter==M）{//i?
Work[j]>
=Need[i][j]?
Finish[i]=true;
//i?
p[n++]=i;
for（intj=0;
Work[j]=Work[j]+Allocation[i][j];
i=-1;
intm;
for（m=0;
m<
m++）
Finish[m]）
if（m==N）//?
Finish[m]=true,?
true,?
returntrue;
else
returnfalse;
publicvoidrecover（intk）{//?
Available[i]=Available[i]+Request[i];
Allocation[k][i]=Allocation[k][i]-Request[i];
Need[k][i]=Need[k][i]+Request[i];
publicvoidshow（）{//?
System.out.println（"
Resource.length;
System.out.print（"
"
+Resource[i]+"
\n\n?
（Available）"
Available.length;
+Available[i]+"
（Max）"
\t?
0"
1"
2"
\t"
+Max[i][j]）;
System.out.println（）;
System.out.println（）;
（Allocation）"
+Allocation[i][j]）;
（Need）"
+Need[i][j]）;
publicstaticvoidmain（String[]args）
throwsArrayIndexOutOfBoundsException{
intResource[]={10,5,7};
intAvailable[]={3,3,2};
intMax[][]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},
{4,3,3}};
intAllocation[][]={{0,1,0},{2,0,0},{3,0,2},
{2,1,1},{0,0,2}};
intRequest[]={1,0,2};
Bankerbanker=newBanker（Resource,Available,Max,Allocation）;
banker.bank（0,Request）;
0?
（1,0,2）
banker.bank（1,Request）;
1?
}
10、总结
十一、参考文献
升级会员 