2.2 银行家算法描述：
我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。
操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。
当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。
若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。
2.3银行家算法原理
2.3.1银行家算法的思路
先对用户提出的请求进行合法性检查，即检查请求的是不大于需要的，是否不大于可利用的。
若请求合法，则进行试分配。
最后对试分配后的状态调用安全性检查算法进行安全性检查。
若安全，则分配，否则，不分配，恢复原来状态，拒绝申请。
2.3.2银行家算法中用到的主要数据结构
可利用资源向量intAvailable[j]j为资源的种类。
最大需求矩阵intMax[i][j]i为进程的数量。
分配矩阵intAllocation[i][j]
需求矩阵intneed[i][j]=Max[i][j]-Allocation[i][j]
申请各类资源数量intRequesti[j]i进程申请j资源的数量
工作向量intWork[x]intFinish[y]
2.3.3银行家算法bank（）
进程i发出请求申请k个j资源，Requesti[j]=k
（1）检查申请量是否不大于需求量：
Requesti[j]<=need[i,j],若条件不符重新输入，不允许申请大于需求量。
（2）检查申请量是否小于系统中的可利用资源数量：
Requesti[j]<=available[i,j]，若条件不符就申请失败，阻塞该进程，用goto语句跳转到重新申请资源。
（3）若以上两个条件都满足，则系统试探着将资源分配给申请的进程，并修改下面数据结构中的数值：
Available[i,j]=Available[i,j]-Requesti[j]；
Allocation[i][j]=Allocation[i][j]+Requesti[j]；
need[i][j]=need[i][j]-Requesti[j]；
（4）试分配后，执行安全性检查，调用safe（）函数检查此次资源分配后系统是否处于安全状态。
若安全，才正式将资源分配给进程；否则本次试探分配作废，恢复原来的资源分配状态，让该进程等待。
（5）用do{…}while循环语句实现输入字符y/n判断是否继续进行资源申请。
2.3.4安全性检查算法（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都满足，则表示系统处于安全状态，否则，处于不安全状态。
第三章银行家算法流程图
3.1系统主要过程流程图
3.2银行家算法流程图
3.3、安全性算法流程图
第四章源程序结构分析
4.1程序结构
4.1.1初始化chushihua（）：
用于程序开始进行初始化输入数据：
进程数量、资源种类、各种资源可利用数量、各进程的各种资源已分配数量、各进程对各类资源最大需求数等。
4.1.2当前安全性检查safe（）：
用于判断当前状态安全性，根据不同地方的调用提示处理不同。
4.1.2银行家算法bank（）：
进行银行家算法模拟实现的模块，调用其他各个模块进行银行家算法模拟过程。
4.1.4显示当前状态show（）：
显示当前资源分配详细情况，包括：
各种资源的总数量（all）、系统目前各种资源可用的数量、各进程已经得到的资源数量、各进程还需要的资源量。
4.1.5主程序main（）
逐个调用初始化、显示状态、安全性检查、银行家算法函数，使程序有序的进行。
4.2数据结构
程序使用的全局变量：
constintx=10，y=10；//定义常量
intAvailable[x];//各种资源可利用的数量
intAllocation[y][y];//各进程当前已分配的资源数量
intMax[y][y];//各进程对各类资源的最大需求数
intNeed[y][y];//还需求矩阵
intRequest[x];//申请各类资源的数量
intWork[x];//工作向量，表系统可提供给进程运行所需各类资源数量
intFinish[y];//表系统是否有足够的资源分配给进程，0为否，1为是
intp[y];//存储安全序列
inti,j;//全局变量，主要用于循环语句中
intn,m;//n为进程的数量,m为资源种类数
intl=0,counter=0;
4.3函数声明
voidchushihua（）; //系统初始化函数
voidsafe（）; //安全性算法函数
voidbank（）;//银行家算法函数
voidshow（）; //输出当前资源分配情况
4.4主函数main（）
intmain（）
{
cout<<……//显示程序开始提示信息
chushihua（）;//初始化函数调用
cout<showdata（）;//输出初始化后的状态
//===判断当前状态的安全性===
safe（）;//安全性算法函数调用
if（lcout<<"\n当前状态不安全，无法申请,程序退出!
!
!
!
!
"<cout<system（"pause"）;
sign（）;//调用签名函数
return0;//break;
}
else{
inti;//局部变量
l=0;
cout<<"\n安全的状态!
!
!
"<cout<<"安全序列为:
";
cout<for（i=1;icout<<"==>>"<<"进程"<<"（"<}
for（i=0;icout<}
bank（）;//银行家算法函数调用
return0;
}
第五章银行家算法代码实现
5.1源程序代码：
#include
#include
#include
usingnamespacestd;
#defineTRUE1//定义TRUE=1
#defineFALSE0//定义FLASE=0
voidbank（vector,vector>,vector>,int,int）;//声明bank（应行家算法）
intsafe（vectorAvailable,vector>Need,vector>Allocation,intn,intm）;//声明safe（）安全性算法
voidinit（）;
/*************************************主函数main（）**************************************************************/
voidmain（）
{
init（）;
intsafe（vectorAvailable,vector>Need,vector>Allocation,intn,intm）;
}
/**************************************初始化函数init（）*********************************************************/
//下面的是在dos命令下使用的程序
voidinit（）
{
intm;//m资源类数
intn;//进程数
cout<<"输入资源类数"<cin>>m;
vectorAvailable（m）;//动态申请数组Available可用资源向量
cout<<"输入各类资源总数:
"<
for（inti=0;i{
cout<<"输入R"<";
cin>>Available[i];
}
cout<<"\n输入进程数"<cin>>n;
vector>Max（n,vector（m））;
{
cout<<"输入进程"<for（intj=0;j{
cout<<"输入需要R"<cin>>Max[i][j];
while（Max[i][j]>Available[j]）
{
cout<cin>>Max[i][j];
}
}
}
cout<<"输入已分配的Allocation"<vector>Allocation（n,vector（m））;
vector>Need（n,vector（m））;
for（i=0;i{
cout<<"输入为进程"<for（intj=0;j{
cout<<"输入分配R"<cin>>Allocation[i][j];
while（Allocation[i][j]>Max[i][j]）
{
cout<cin>>Allocation[i][j];
}
Need[i][j]=Max[i][j]-Allocation[i][j];
Available[j]=Available[j]-Allocation[i][j];
}
}
intsafe（vectorAvailable,vector>Need,vector>Allocation,intn,intm）;
cout<<"此状态安全!
"<bank（Available,Need,Allocation,n,m）;//调用银行家算法bank（）函数
}//下面的是在文件中导入我们所需的信息
/*/voidinit（）
{
intm;//m资源类数
intn;//进程数
cout<<"输入资源类数"<cin>>m;
vectorAvailable（m）;//动态申请数组Available可用资源向量
cout<<"输入各类资源总数:
"<FILE*fp;
fp=fopen（"Available.txt","r+"）;
cout<<"从Available.txt文件中读入数据，并输出"<for（inti=0;i{
fscanf（fp,"%d",&Available[i]）;
cout<}
fclose（fp）;
cout<<"\n输入进程数"<cin>>n;
vector>Max（n,vector（m））;
fp=fopen（"Max.txt","r+"）;
cout<<"从Max.txt文件中读入数据，并输出"<for（i=0;i{
for（intj=0;j{
fscanf（fp,"%d",&Max[i][j]）;
cout<}
cout<}
fclose（fp）;
cout<<"输入已分配的Allocation"<vector>Allocation（n,vector（m））;
vector>Need（n,vector（m））;
fp=fopen（"Allocation.txt","r+"）;
cout<<"Allocation.txt从文件中读入数据，并输出"<for（i=0;i{
for（intj=0;j{
fscanf（fp,"%d",&Allocation[i][j]）;
Need[i][j]=Max[i][j]-Allocation[i][j];//在初始化Max时，同时初始化Need数组
Available[j]=Available[j]-Allocation[i][j];//在初始化Max时，同时修改Available数组
cout<}
cout<}
fclose（fp）;
intsafe（vectorAvailable,vector>Need,vector>Allocation,intn,intm）;
cout<<"此状态安全!
"<bank（Available,Need,Allocation,n,m）;//调用银行家算法bank（）函数
}
/*/
/**************************************银行家算法bank（）函数*********************************************************/
voidbank（vectorAvailable,vector>Need,vector>Allocation,intn,intm）
{
vectorRequest（m）;
intall=0;
//定义变量all，如果all==0，表示进程已经运行完，如果all>=1，表示还有进程没有运行完
for（inti=0;ifor（intj=0;jall+=Need[i][j];
if（0==all）
{
cout<<"所有进程已经运行完，结束"<exit（0）;
}
intjc;//任选一个进程
charagain;
all=0;//重新初始化all，
while
（1）
{
while（all==0）
{
all=0;
//如果all==0，表示进程已经运行完，如果all>=1，表示还有进程没有运行完
//循环直至all>0,即找到一个未运行完的进程
cout<<"任选一个进程作为当前进程0--"<cin>>jc;
for（intj=0;j{
all+=Need[jc][j];
}
if（0==all）
{
cout<<"此进程已经运行，重新输入"<}
}
cout<<"输入该进程的请求向量"<for（i=0;i{
cin>>Request[i];
while（Request[i]>Need[jc][i]||Request[i]>Available[i]）
{
cout<<"请求向量无法满足"<break;
}
}
//////////////////////////////////////////////////////////////////////////
//系统试探着把资源分配给该进程///////////////////////////////////////////
for（i=0;i{
Available[i]=Available[i]-Request[i];
Allocation[jc][i]=Allocation[jc][i]+Request[i];
Need[jc][i]=Need[jc][i]-Request[i];
}
intbb=0;
bb=safe（Available,Need,Allocation,n,m）;//调用安全性算法，判断此次资源分配后，系统是否处安全状态
if（1==bb）
{
cout<<"系统成功分配资源"<}
else
{
cout<<"系统未能成分配资源,收回预分配资源"<for（i=0;i{
Available[i]=Available[i]+Request[i];
Allocation[jc][i]=Allocation[jc][i]-Request[i];
Need[jc][i]=Need[jc][i]+Request[i];
}
}
cout<<"您还想再次请求分配吗?
是请按y/Y,否请按其它键"<cin>>again;
if（again=='y'||again=='Y'）
{
all=0;
continue;
}
break;
}
}
/**************************************安全性算法safe（）函数*********************************************************/
intsafe（vectorAvailable,vector>Need,vector>Allocation,intn,intm）
{
vectorWork（m）,Finish（n）;//申请工作向量work，finish
Work=Available;
vectorcount（n）;//记录安全序列
intlen=-1;//记录安全序列的进程个数，如果len==n，即表示所有的finish【i】=true，处于安全状态
for（inti=0;ifor（i=0;i{
intneeded=1;
for（intj=0;j{
if（Need[i][j]<=Work[j]）
{
needed=needed*TRUE;
}
elseneeded=needed*FALSE;
}
if（（Finish[i]==FALSE）&&needed==1）
{
for（j=0;j{
Work[j]=Work[j]+Allocation[i][j];
}
Finish[i]=TRUE;
len=len+1;
count[len]=i;
i=-1;
}
}
if（len==n-1）
{
cout<<"系统是安全的"<cout<<"安全序列"<for（i=0;i<=len;i++）
{
cout<if（i!
=len）
{
cout<<"-->";
}
}
cout<returnTRUE;
升级会员 