不安全状态:
不存在一个安全序列，不安全状态一定导致死锁。
二．银行家算法
1、银行家算法中的数据结构
1）可利用资源向量Available
它是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源数目。
其数值随该类资源的分配和回收而动态地改变。
如果Available[j]=K,则表示系统中现有Rj类资源K个。
2）最大需求短阵Max
这是—个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。
如果Max（i，j）＝K，表示进程i需要Rj类资源的最大数目为K。
3）分配短阵Allocation
这是一个n×m的矩阵，它定义了系统中每一类资源当前已分配给每个进程的资源数。
如果Allocation（i,j）＝K，表示进程i当前已分得Rj类资源的数目为K。
4）需求矩阵Need
它是一个n×m的矩阵，用以表示每一个进程尚需的各类资源数，如果Need[i,j]=K，则表示进程i还需要Rj类资源k个，方能完成其任务。
上述三个矩阵间存在下述关系：
Need[i,j]=Max[i,j]-Allocation[i,j]
2、银行家算法
设Requesti是进程Pi的请求向量。
如果Requesti[j]＝k，表示进程只需要k个Rj类型的资源。
当Pi发出资源请求后，系统按下述步骤进行检查：
1）如果Requesti[j]<=Need[i,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等待。
3、安全性算法
系统所执行的安全性算法可描述如下：
1）设置两个向量
①、工作向量Work。
它表示系统可提供给进程继续运行所需要的各类资源数目，它含有m个元素，执行安全算法开始时，Work=Available。
②、Finish。
它表示系统是否有足够的资源分配给进程，使之运行完成，开始时先做Finish[i]:
=false；当有足够资源分配给进程时，令Finish[i]:
=true。
2）从进程集合中找到一个能满足下述条件的进程：
①、Finish[i]=false;②、Need[i,j]<=Work[j];如找到，执行步骤（3）；否则，执行步骤（4）。
3）当进程Pi获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：
Work[j]:
=Work[i]+Allocation[i,j];
Finish[i]:
=true;
gotostep2；
4）如果所有进程的Finish[i]:
=true，则表示系统处于安全状态；否则，系统处于不安全状态。
三．银行家算法之例
假定系统中有五个进程：
{P0，P1，P2，P3，P4}和三种类型的资源{A，B，C}，每一种资源的数量分别为10、5、7,在T0时刻的资源分配情况如图1所示。
资源情况
进程
Max
Allocation
Need
Available
ABC
ABC
ABC
ABC
P0
753
010
743
332
（230）
P1
322
200
（302）
122
（020）
P2
902
302
600
P3
222
211
011
P4
433
002
431
图1T0时刻的资源分配表
（1）T0时刻的安全性：
利用安全性算法对T0时刻的资源分配情况进行分析（如图2）可知，在T0时刻存在着一个安全序列｛P1，P3，P4，P2，P0｝，故系统是安全的。
资源情况
进程
Work
Need
Allocation
Work+Allocation
Finish
ABC
ABC
ABC
ABC
P1
332
122
200
532
true
true
true
true
true
P3
532
011
211
743
P4
743
431
002
745
P2
745
600
302
1047
P0
1047
743
010
1057
图2T0时刻的安全序列
（2）P1请求资源：
P1发出请求向量Request1（1,0,2）,系统按银行家算法进行检查：
①Request1（1,0,2）<=Need1（1,2,2）
②Request1（1,0,2）<=Available1（3,3,2）
③系统先假定可为P1分配资源，并修改Available,Allocation1和Need1向量，由此形成资源变化情况如图1中的圆括号所示。
④再利用安全性算法检查此时系统是否安全。
如图3所示。
资源情况
进程
Work
Need
Allocation
Work+Allocation
Finish
ABC
ABC
ABC
ABC
P1
230
020
302
532
true
true
true
true
true
P3
532
011
211
743
P4
743
431
002
745
P0
745
743
010
755
P2
755
600
302
1057
图3P1申请资源时的安全性检查
由所进行的安全性检查得知，可以找到一个安全序列｛P1,P3,P4,P2,P0｝。
因此系统是安全的，可以立即将P1所申请的资源分配给它。
（3）P4请求资源：
P4发出请求向量Request4（3,3,0）,系统按银行家算法进行检查：
①Request4（3,3,0）≤Need4（4,3,1）;
②Request4（3,3,0）不小于等于Available（2,3,0）,让P4等待。
（4）P0请求资源：
P0发出请求向量Request0（0,2,0）,系统按银行家算法进行检查。
①Request0（0,2,0）≤Need0（7,4,3）;
②Request0（0,2,0）≤Available（2,3,0）;
③系统暂时先假定可为P0分配资源，并修改有关数据，如图4所示。
资源情况
进程
Allocation
Need
Available
ABC
ABC
ABC
P0
030
732
210
P1
302
020
P2
302
600
P3
211
011
P4
002
432
图4为P0分配资源后的有关资源数据
（5）进行安全性检查：
可用资源Available（2,1,0）已不能满足任何进程的需要，故系统进入不安全状态，此时系统不分配资源。
四：
详细设计及编码
1）银行家算法流程图
五：
程序源代码
#include
#include
#include
#include
//定义全局变量
constintx=20,y=20;//常量，便于修改
intAvailable[x];//各资源可利用的数量
intAllocation[y][y];//各进程当前已分配的资源数量
intMax[y][y];//各进程对各类资源的最大需求数
intNeed[y][y];//尚需多少资源
intRequest[x];//申请多少资源
intWork[x];//工作向量，表示系统可提供给进程继续运行所需的各类资源数量
intFinish[y];//表示系统是否有足够的资源分配给进程，1为是
intp[y];//存储安全序列
inti,j;//i表示进程，j表示资源
intn,m;//n为进程i的数量,m为资源j种类数
intl=0;//l用来记录有几个进程是Finish[i]=1的，当l=n是说明系统状态是安全的
intcounter=0;
//函数声明
voidchushihua（）;//初始化函数
voidsafe（）;//安全性算法
voidshow（）;//函数show,输出当前状态
voidbank（）;//银行家算法
//voidjieshu（）;//结束函数
voidchushihua（）
{
cout<<"输入进程的数量:
";//从此开始输入有关数据
cin>>n;
cout<<"输入资源种类数:
";
cin>>m;
cout<"<for（j=0;j{
cout<<"输入资源"<";
cin>>Available[j];//输入数字的过程...
Work[j]=Available[j];//初始化Work[j]，它的初始值就是当前可用的资源数
}
cout<"<for（i=0;i{
for（j=0;j{
cout<<"输入进程"<";
cin>>Allocation[i][j];
}
cout<Finish[i]=0;//初始化Finish[i]
}
cout<"<for（i=0;i{
for（j=0;j{
cout<<"输入进程"<";
cin>>Max[i][j];
if（Max[i][j]>=Allocation[i][j]）//若最大需求大于已分配，则计算需求量
Need[i][j]=Max[i][j]-Allocation[i][j];
else
Need[i][j]=0;//Max小于已分配的时候，此类资源已足够不需再申请
}
cout<}
cout<}
//安全性算法函数
voidsafe（）
{
l=0;
for（i=0;i{//i++
if（Finish[i]==0）
{//逐个查找Finish[i]==0的进程条件一
counter=0;//记数器
for（j=0;j{
if（Work[j]>=Need[i][j]）counter=counter+1;//可用大于需求，记数
}
if（counter==m）//i进程的每类资源都符合Work[j]>=Need[i][j]条件二
{
p[l]=i;//存储安全序列
Finish[i]=1;//i进程标志为可分配
for（j=0;jWork[j]=Work[j]+Allocation[i][j];//释放资源
l=l+1;//记数,现在有L个进程是安全的，当L=N时说明满足安全序列
i=-1;//从第一个进程开始继续寻找满足条件一二的进程
}
}
}
}
//显示当前状态函数
voidshow（）//函数show,输出当前资源分配情况
{
inti,j;//局部变量
intAll[y];//各种资源的总数量
cout<<"当前的状态为：
"<cout<<"各种资源的总数量:
"<for（j=0;j{
cout<<"资源"<";
All[j]=Available[j];//总数量=可用的+已分配的
for（i=0;icout<}
cout<"<for（j=0;jcout<<"资源"<"<cout<"<for（j=0;jcout<for（i=0;i{
cout<<"进程"<";
for（j=0;jcout<}
cout<"<for（j=0;jcout<for（i=0;i{
cout<<"进程"<";
for（j=0;jcout<}
}
//银行家算法函数
voidbank（）
{
cout<"<intk=0;//用于输入进程编号
boolr=false;//初值为假，输入Y继续申请则置为真
do{//输入请求
cout<<"输入申请资源的进程（0-"<";
cin>>k;
cout<while（k>n-1）//输入错误处理
{
cout<"<cout<";
cin>>k;
cout<}
cout<"<for（j=0;j{
do{//do……while循环判断申请输入的情况
cout<<"进程"<";
cin>>Request[j];
cout<if（Request[j]>Need[k][j]）
{//申请大于需求量时出错，提示重新输入（贷款数目不允许超过需求数目）
cout<<"申请大于需要量!
"<cout<<"申请的资源"<"<cout<<"重新输入!
"<}
else//先判断是否申请大于需求量，再判断是否申请大于可利用量
if（Request[j]>Available[j]）
{//申请大于可利用量，应该阻塞等待？
……？
？
？
cout<<"\n没有那么多资源，目前可利用资源"<"<Finish[k]=0;//该进程等待
gotoppp;//goto语句跳转，结束本次申请
}
}while（Request[j]>Need[k][j]）;//Request[j]>Available[j]||
}
//改变Avilable、Allocation、Need的值
for（j=0;j{
Available[j]=Available[j]-Request[j];
Allocation[k][j]=Allocation[k][j]+Request[j];
Need[k][j]=Need[k][j]-Request[j];
Work[j]=Available[j];
}
//判断当前状态的安全性
safe（）;//调用安全性算法函数
if（l{
l=0;
cout<<"\n试分配后，状态不安全,所以不予分配!
恢复原状态"<//恢复数据
for（j=0;j{
Available[j]=Available[j]+Request[j];
Allocation[k][j]=Allocation[k][j]-Request[j];
Need[k][j]=Need[k][j]+Request[j];
Work[j]=Available[j];
}
for（i=0;iFinish[i
升级会员 