银行家算法及流程图

㈠ 操作系统题目,好的追加高分,感谢大虾

http://tieba..com/f?kz=588380474

http://blog.163.com/mqt_signature/blog/static/1049595722009429104343122/

或者看看这个，可是你需要的

《操作系统--银行家算法》
课程设计报告

1 课程设计目的 …………………………………………………… 1
2 课程设计的要求 ………………………………………………… 1
3 课程设计题目描述 ……………………………………………… 2
4 课程设计之银行家算法原理 …………………………………… 2
5 源程序结构分析及代码实现 …………………………………… 4
6 课程设计总结 …………………………………………………… 25
一、课程设计的目的
操作系统是计算机系统的核心系统软件，它负责控制和管理整个系统的资源并组织用户协调使用这些资源，使计算机高效的工作。《操作系统课程设计》是《操作系统》理论课的必要补充，是复习和检验所学课程的重要手段，本课程设计的目的是综合应用学生所学知识，通过实验环节，加深学生对操作系统基本原理和工作过程的理解，提高学生独立分析问题、解决问题的能力，增强学生的动手能力。
二、课程设计的要求
1．分析设计内容，给出解决方案（要说明设计实现的原理，采用的数据结构）。
2．画出程序的基本结构框图和流程图。
3．对程序的每一部分要有详细的设计分析说明。
4．源代码格式要规范。
5．设计合适的测试用例，对得到的运行结果要有分析。
6．设计中遇到的问题，设计的心得体会。
7．按期提交完整的程序代码、可执行程序和课程设计报告。

三、课程设计题目描述
银行家算法是一种最有代表性的避免死锁的算法。
要解释银行家算法，必须先解释操作系统安全状态和不安全状态。
安全状态：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。安全状态一定是没有死锁发生。
不安全状态:不存在一个安全序列。不安全状态不一定导致死锁。
那么什么是安全序列呢？
安全序列：一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。
银行家算法：
我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。

四、课程设计之银行家算法原理
1．银行家算法的思路
先对用户提出的请求进行合法性检查，即检查请求的是不大于需要的，是否不大于可利用的。若请求合法，则进行试分配。最后对试分配后的状态调用安全性检查算法进行安全性检查。若安全，则分配，否则，不分配，恢复原来状态，拒绝申请。

2．银行家算法中用到的主要数据结构
可利用资源向量 int Available[j] j为资源的种类。
最大需求矩阵 int Max[i][j] i为进程的数量。
分配矩阵 int Allocation[i][j]
需求矩阵 int need[i][j]= Max[i][j]- Allocation[i][j]
申请各类资源数量 int Request i[j] i进程申请j资源的数量
工作向量 int Work[x] int Finish[y]

3．银行家算法bank()
进程i发出请求申请k个j资源，Request i[j]=k
(1)检查申请量是否不大于需求量：Request i[j]<=need[i,j],若条件不符重新输入，不允许申请大于需求量。
(2)检查申请量是否小于系统中的可利用资源数量：Request i[j]<=available[i,j]，若条件不符就申请失败，阻塞该进程，用goto语句跳转到重新申请资源。
(3)若以上两个条件都满足，则系统试探着将资源分配给申请的进程，并修改下面数据结构中的数值：
Available[i,j]= Available[i,j]- Request i[j]；
Allocation[i][j]= Allocation[i][j]+ Request i[j]；
need[i][j]= need[i][j]- Request i[j]；
(4)试分配后，执行安全性检查，调用safe()函数检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程；否则本次试探分配作废，恢复原来的资源分配状态，让该进程等待。
(5)用do{…}while 循环语句实现输入字符y/n判断是否继续进行资源申请。

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；
goto step 2；

(4)如果所有的Finish[i]=1都满足，则表示系统处于安全状态，否则，处于不安全状态。

五、源程序结构分析及代码实现

1．程序结构

程序共有以下五个部分：

(1).初始化chushihua()：用于程序开始进行初始化输入数据：进程数量、资源种类、各种资源可利用数量、各进程的各种资源已分配数量、各进程对各类资源最大需求数等。
(2).当前安全性检查safe()：用于判断当前状态安全性，根据不同地方的调用提示处理不同。
(3).银行家算法bank()：进行银行家算法模拟实现的模块，调用其他各个模块进行银行家算法模拟过程。
(4).显示当前状态show()：显示当前资源分配详细情况，包括：各种资源的总数量(all)、系统目前各种资源可用的数量、各进程已经得到的资源数量、各进程还需要的资源量。
(5).主程序main()
逐个调用初始化、显示状态、安全性检查、银行家算法函数，使程序有序的进行。

2．数据结构
程序使用的全局变量：
const int x=10，y=10； //定义常量
int Available[x]; //各种资源可利用的数量
int Allocation[y][y]; //各进程当前已分配的资源数量
int Max[y][y]; //各进程对各类资源的最大需求数
int Need[y][y]; //还需求矩阵
int Request[x]; //申请各类资源的数量
int Work[x]; //工作向量，表系统可提供给进程运行所需各类资源数量
int Finish[y]; //表系统是否有足够的资源分配给进程，0为否，1为是
int p[y]; //存储安全序列
int i,j; //全局变量，主要用于循环语句中
int n,m; //n为进程的数量,m为资源种类数
int l=0,counter=0;

3．函数声明
void chushihua(); //系统初始化函数
void safe(); //安全性算法函数
void bank(); //银行家算法函数
void show (); //输出当前资源分配情况

4．主函数main()
int main()
{
cout<<…… //显示程序开始提示信息
chushihua(); //初始化函数调用
cout<<endl<<endl;
showdata(); //输出初始化后的状态
//===判断当前状态的安全性===
safe(); //安全性算法函数调用
if (l<n){
cout<<"\n当前状态不安全，无法申请,程序退出!!!!!"<<endl;
cout<<endl;
system("pause");
sign(); //调用签名函数
return 0; // break;
}
else{
int i; //局部变量
l=0;
cout<<"\n安全的状态!!!"<<endl;
cout<<"安全序列为: ";
cout<<endl<<"进程"<<"("<<p[0]<<")"; //输出安全序列，考虑显示格式，先输出第一个
for (i=1; i<n; i++){
cout<<"==>>"<<"进程"<<"("<<p[i]<<")";
}
for (i=0; i<n; i++) Finish[i]=0; //所有进程置为未分配状态
cout<<endl<<endl;
}
bank(); //银行家算法函数调用
return 0;
}

5. 操作系统银行家算法流程图：

2.源程序代码：
#include <iostream.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//定义全局变量
const int x=10,y=10; //常量，便于修改
int Available[x]; //各资源可利用的数量
int Allocation[y][y]; //各进程当前已分配的资源数量
int Max[y][y]; //各进程对各类资源的最大需求数
int Need[y][y]; //尚需多少资源
int Request[x]; //申请多少资源
int Work[x]; //工作向量，表示系统可提供给进程继续运行所需的各类资源数量
int Finish[y]; //表示系统是否有足够的资源分配给进程，1为是
int p[y]; //存储安全序列
int i,j; //i表示进程，j表示资源
int n,m; //n为进程i的数量,m为资源j种类数
int l=0; //l用来记录有几个进程是Finish[i]=1的，当l=n是说明系统状态是安全的
int counter=0;

//函数声明
void chushihua(); //初始化函数
void safe(); //安全性算法
void show(); //函数show,输出当前状态
void bank(); //银行家算法
void jieshu(); //结束函数

void chushihua()
{
cout<<"输入进程的数量: ";//从此开始输入有关数据
cin>>n;
cout<<"输入资源种类数: ";
cin>>m;
cout<<endl<<"输入各种资源当前可用的数量( "<<m<<" 种): "<<endl;
for (j=0; j<m; j++)
{
cout<<"输入资源 "<<j<<" 可利用的数量Available["<<j<<"]: ";
cin>>Available[j]; //输入数字的过程...
Work[j]=Available[j]; //初始化Work[j]，它的初始值就是当前可用的资源数
}

cout<<endl<<"输入各进程当前已分配的资源数量Allocation["<<n<<"]["<<m<<"]: "<<endl;
for (i=0; i<n; i++)
{
for (j=0; j<m; j++)
{
cout<<" 输入进程 "<<i<<" 当前已分配的资源 "<<j<<" 数量: ";
cin>>Allocation[i][j];
}
cout<<endl;
Finish[i]=0;//初始化Finish[i]
}

cout<<endl<<"输入各进程对各类资源的最大需求Max["<<n<<"]["<<m<<"]: "<<endl;
for (i=0; i<n; i++)
{
for (j=0; j<m; j++)
{
cout<<" 输入进程 "<<i<<" 对资源 "<<j<<" 的最大需求数: ";
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<<endl;
}
cout<<endl<<"初始化完成"<<endl;
}

//安全性算法函数
void safe()
{
l=0;
for (i=0; i<n;i++)
{ //i++
if (Finish[i]==0)
{ //逐个查找Finish[i]==0的进程 条件一
counter=0; //记数器

for (j=0; j<m; 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; j<m;j++)
Work[j]=Work[j]+Allocation[i][j]; //释放资源
l=l+1; //记数,现在有L个进程是安全的，当L=N时说明满足安全序列
i= -1; //从第一个进程开始继续寻找满足条件一二的进程
}
}
}
}

//显示当前状态函数
void show() //函数show,输出当前资源分配情况
{
int i,j; //局部变量
int All[y]; //各种资源的总数量
int L1; //局部变量L1

cout<<"当前的状态为："<<endl;
cout<<"各种资源的总数量:"<<endl;
for (j=0;j<m;j++)
{
cout<<" 资源"<<j<<": ";
All[j]=Available[j]; //总数量=可用的+已分配的
for (i=0;i<n;i++) All[j]+=Allocation[i][j];

cout<<All[j]<<" ";
}

cout<<endl<<"当前各种资源可用的量为(available):"<<endl;
for (j=0;j<m;j++)
cout<<" 资源"<<j<<": "<<Available[j]<<" ";

cout<<endl<<"各进程已经得到的资源量(allocation): "<<endl;
for(i=0;i<=m;i++)
{
for (j=i;j<m;j++) cout<<" 资源"<<j;
cout<<endl;
for(L1=0;L1<n;L1++)
{
cout<<"进程"<<L1<<":";
for (j=i;j<m;j++) cout<<Allocation[L1][j]<<" ";
cout<<endl;
}
}

cout<<endl<<"各进程还需要的资源量(need):"<<endl;
for(i=0;i<=m;i++)
{
for (j=i;j<m;j++) cout<<" 资源"<<j;
cout<<endl;
for(L1=0;L1<n;L1++)
{
cout<<"进程"<<L1<<":";
for (j=i;j<m;j++) cout<<Need[L1][j]<<" ";
cout<<endl;
}
}
}

//银行家算法函数
void bank()
{
cout<<endl<<"进程申请分配资源："<<endl;

int k=0; //用于输入进程编号
bool r=false; // 初值为假，输入Y继续申请则置为真
do{//输入请求
cout<<"输入申请资源的进程(0-"<<n-1<<"): ";
cin>>k;
cout<<endl;
while(k>n-1) //输入错误处理
{
cout<<endl<<"输入错误，重新输入："<<endl;
cout<<endl<<"输入申请资源的进程(0--"<<n-1<<"): ";
cin>>k;
cout<<endl;
}
cout<<endl<<"输入该进程申请各类资源的数量: "<<endl;
for (j=0; j<m; j++)
{
do{ //do……while 循环判断申请输入的情况
cout<<"进程 "<<k<<" 申请资源["<<j<<"]的数量:";
cin>>Request[j];
cout<<endl;
if(Request[j]>Need[k][j]){ //申请大于需求量时出错，提示重新输入（贷款数目不允许超过需求数目）
cout<<"申请大于需要量!"<<endl;
cout<<"申请的资源"<<j<<"的数量为"<<Request[j]<<",大于进程"<<k<<"对该资源需求量"<<Need[k][j]<<"。"<<endl;
cout<<"重新输入!"<<endl;
}
else //先判断是否申请大于需求量，再判断是否申请大于可利用量
if(Request[j]>Available[j]){ //申请大于可利用量， 应该阻塞等待？…… ？？？
cout<<"\n没有那么多资源，目前可利用资源"<<j<<"数量为"<<Available[j]<<",本次申请不成功，进程等待!"<<endl;
Finish[k]=0; //该进程等待
goto ppp; //goto语句 跳转，结束本次申请
}
}while(Request[j]>Need[k][j]); //Request[j]>Available[j]||
}

//改变Avilable、Allocation、Need的值
for (j=0; j<m; 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<n)
{
l=0;
cout<<"\n试分配后，状态不安全,所以不予分配!恢复原状态"<<endl;
//恢复数据
for (j=0; j<m; 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; i<n; i++)
Finish[i]=0; //进程置为未分配状态
}
else
{
l=0;
cout<<"\n申请资源成功!!!"<<endl;

for(j=0;j<m;j++)
{
if(Need[k][j]==0);
else { //有一种资源还没全部申请到，则该进程不可执行，不能释放拥有的资源
l=1; //置l为1，作为判断标志
break;
}
}
if(l!=1){ //进程可以执行，则释放该进程的所有资源
for (j=0;j<m;j++){
Available[j]=Available[j]+Allocation[k][j];
Allocation[k][j]=0;
}
cout<<"该进程已得到所有需求资源，执行后将释放其所有拥有资源！"<<endl;
}
l=0; //归零

cout<<"\n安全的状态!"<<endl;
cout<<"安全序列为: ";
cout<<endl<<"进程"<<"("<<p[0]<<")"; //输出安全序列，考虑显示格式，先输出第一个
Finish[0]=0;
for (i=1; i<n; i++){
cout<<"==>>"<<"进程"<<"("<<p[i]<<")";
Finish[i]=0; //所有进程置为未分配状态
}
cout<<endl<<endl;
}
show(); //显示当前状态
ppp: //申请大于可利用量， 应该阻塞等待,结束本次资源申请，GOTO 语句跳转至此
cout<<endl<<"是否继续申请资源(y/n) ?";
char* b=new char; //输入y/n，判断是否继续申请 <<endl
cin>>b;
cout<<endl;
cout<<"-------------------------------------------"<<endl<<endl;
cout<<endl;
if(*b=='y'||*b=='Y')
r=true;
else{
r=false; //输入非 Y 则令 R =false
jieshu(); //调用结束函数
}
} while (r==true);
}

//结束函数
void jieshu()
{
cout<<endl<<endl;
cout<<"\t\t 演示计算完毕"<<endl;
cout<<endl<<endl;
}

//主函数
int main()
{
cout<<endl<<endl<<"\t\t\t\t模拟银行家算法"<<endl<<endl;
chushihua(); //初始化函数调用
cout<<endl;
show(); //输出当前状态
safe(); //判断当前状态的安全性
if (l<n) //l在safe中是用来记录安全的进程的个数的
{
cout<<"\n当前状态不安全，拒绝申请！"<<endl;
cout<<endl;
return 0;
}
else
{
int i; //局部变量
l=0;
cout<<endl<<"\n当前的状态是安全的!安全序列为:"<<endl;
cout<<"进程"<<"("<<p[0]<<")"; //输出安全序列
for (i=1; i<n; i++) cout<<"->>"<<"进程"<<"("<<p[i]<<")";
for (i=0; i<n; i++) Finish[i]=0; //所有进程置为未分配状态
cout<<endl;
}

bank(); //调用银行家算法函数
cout<<"\t\t 演示计算完毕"<<endl;
return 0;
}

运行结果：
1.初始化结果
2.检测系统资源分配是否安全结果：

六、课程设计的总结
操作系统的基本特征是并发与共享。系统允许多个进程并发执行，并且共享系统的软、硬件资源。为了最大限度的利用计算机系统的资源，操作系统应采用动态分配的策略，但是这样就容易因资源不足，分配不当而引起“死锁”。而我本次课程设计就是得用银行家算法来避免“死锁”。银行家算法就是一个分配资源的过程，使分配的序列不会产生死锁。此算法的中心思想是：按该法分配资源时，每次分配后总存在着一个进程，如果让它单独运行下去，必然可以获得它所需要的全部资源，也就是说，它能结束，而它结束后可以归还这类资源以满足其他申请者的需要。
本次程序就是按照上面的思路展开的。但是因为时间上的仓促，本课程设计的存在着以下不足：一、不能实现并发操作，即当总资源同时满足几个进程所需要的资源数时，这些进程不能同时进行，只能一一按进程顺序执行。二、扫描进程顺序单一，只能按进程到来的顺序（即编号）来扫描，从而产生的安全顺序只能是在这个顺序的基础上产生的，而其实安全顺序是有多个的。三、对进程数和资源数进行的数量进行了限制，都只能最多有十个。四、运行程序后，界面较差，进程数，所需要资源数，已分配资源数，能用资源数，不能一目了然。
这次课程设计时间上虽说仓促点，但是我依然学到了很多的实用性知识。除了更深的了解这个算法，而且对C语言进行了复习，而且其过程中有很多的知识点都不记得了，所以在此感谢在此过程中帮助过我的老师和同学。
最后的感悟就是：只要你亲自动手，你就能学到知识。
再次感谢帮助过我的老师和同学！

㈡ 银行家算法的算法实现

在避免死锁的方法中，所施加的限制条件较弱，有可能获得令人满意的系统性能。在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发生死锁。
银行家算法的基本思想是分配资源之前，判断系统是否是安全的；若是，才分配。它是最具有代表性的避免死锁的算法。
设进程cusneed提出请求REQUEST [i]，则银行家算法按如下规则进行判断。
(1)如果REQUEST [cusneed] [i]<= NEED[cusneed][i]，则转（2)；否则，出错。
(2)如果REQUEST [cusneed] [i]<= AVAILABLE[i]，则转（3)；否则，等待。
(3)系统试探分配资源，修改相关数据：
AVAILABLE[i]-=REQUEST[cusneed][i];
ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];
NEED[cusneed][i]-=REQUEST[cusneed][i];
(4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。 （1)设置两个工作向量Work=AVAILABLE;FINISH
(2)从进程集合中找到一个满足下述条件的进程，
FINISH==false;
NEED<=Work;
如找到，执行（3)；否则，执行（4)
(3)设进程获得资源，可顺利执行，直至完成，从而释放资源。
Work=Work+ALLOCATION;
Finish=true;
GOTO 2
(4)如所有的进程Finish= true，则表示安全；否则系统不安全。
银行家算法流程图
算法（C语言实现） #include<STRING.H>#include<stdio.h>#include<stdlib.h>#include<CONIO.H>/*用到了getch()*/#defineM5/*进程数*/#defineN3/*资源数*/#defineFALSE0#defineTRUE1/*M个进程对N类资源最大资源需求量*/intMAX[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};/*系统可用资源数*/intAVAILABLE[N]={10,5,7};/*M个进程已分配到的N类数量*/intALLOCATION[M][N]={{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0}};/*M个进程已经得到N类资源的资源量*/intNEED[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};/*M个进程还需要N类资源的资源量*/intRequest[N]={0,0,0};voidmain(){inti=0,j=0;charflag;voidshowdata();voidchangdata(int);voidrstordata(int);intchkerr();showdata();enter:{printf(请输入需申请资源的进程号（从0到);printf(%d,M-1);printf(）:);scanf(%d,&i);}if(i<0||i>=M){printf(输入的进程号不存在，重新输入! );gotoenter;}err:{printf(请输入进程);printf(%d,i);printf(申请的资源数 );printf(类别:ABC );printf();for(j=0;j<N;j++){scanf(%d,&Request[j]);if(Request[j]>NEED[i][j]){printf(%d,i);printf(号进程);printf(申请的资源数>进程);printf(%d,i);printf(还需要);printf(%d,j);printf(类资源的资源量!申请不合理，出错!请重新选择! );gotoerr;}else{if(Request[j]>AVAILABLE[j]){printf(进程);printf(%d,i);printf(申请的资源数大于系统可用);printf(%d,j);printf(类资源的资源量!申请不合理，出错!请重新选择! );gotoerr;}}}}changdata(i);if(chkerr()){rstordata(i);showdata();}elseshowdata();printf( );printf(按'y'或'Y'键继续,否则退出 );flag=getch();if(flag=='y'||flag=='Y'){gotoenter;}else{exit(0);}}/*显示数组*/voidshowdata(){inti,j;printf(系统可用资源向量: );printf(***Available*** );printf(资源类别:ABC );printf(资源数目:);for(j=0;j<N;j++){printf(%d,AVAILABLE[j]);}printf( );printf( );printf(各进程还需要的资源量: );printf(******Need****** );printf(资源类别:ABC );for(i=0;i<M;i++){printf();printf(%d,i);printf(号进程:);for(j=0;j<N;j++){printf(%d,NEED[i][j]);}printf( );}printf( );printf(各进程已经得到的资源量: );printf(***Allocation*** );printf(资源类别:ABC );for(i=0;i<M;i++){printf();printf(%d,i);printf(号进程:);/*printf(: );*/for(j=0;j<N;j++){printf(%d,ALLOCATION[i][j]);}printf( );}printf( );}/*系统对进程请求响应，资源向量改变*/voidchangdata(intk){intj;for(j=0;j<N;j++){AVAILABLE[j]=AVAILABLE[j]-Request[j];ALLOCATION[k][j]=ALLOCATION[k][j]+Request[j];NEED[k][j]=NEED[k][j]-Request[j];}}/*资源向量改变*/voidrstordata(intk){intj;for(j=0;j<N;j++){AVAILABLE[j]=AVAILABLE[j]+Request[j];ALLOCATION[k][j]=ALLOCATION[k][j]-Request[j];NEED[k][j]=NEED[k][j]+Request[j];}}/*安全性检查函数*/intchkerr()//在假定分配资源的情况下检查系统的安全性{intWORK[N],FINISH[M],temp[M];//temp[]用来记录进程安全执行的顺序inti,j,m,k=0,count;for(i=0;i<M;i++)FINISH[i]=FALSE;for(j=0;j<N;j++)WORK[j]=AVAILABLE[j];//把可利用资源数赋给WORK[]for(i=0;i<M;i++){count=0;for(j=0;j<N;j++)if(FINISH[i]==FALSE&&NEED[i][j]<=WORK[j])count++;if(count==N)//当进程各类资源都满足NEED<=WORK时{for(m=0;m<N;m++)WORK[m]=WORK[m]+ALLOCATION[i][m];FINISH[i]=TRUE;temp[k]=i;//记录下满足条件的进程k++;i=-1;}}for(i=0;i<M;i++)if(FINISH[i]==FALSE){printf(系统不安全!!!本次资源申请不成功!!! );return1;}printf( );printf(经安全性检查，系统安全，本次分配成功。 );printf( );printf(本次安全序列：);for(i=0;i<M;i++)//打印安全系统的进程调用顺序{printf(进程);printf(%d,temp[i]);if(i<M-1)printf(->);}printf( );return0;}

㈢ 银行家算法 操作系统课程设计

这个刚做过，直接贴给你好了，给分吧
#include<iostream.h>
#include<string.h>
#include<stdio.h>
#define False 0
#define True 1
int Max[100][100]={0};//各进程所需各类资源的最大需求
int Avaliable[100]={0};//系统可用资源
char name[100]={0};//资源的名称
int Allocation[100][100]={0};//系统已分配资源
int Need[100][100]={0};//还需要资源
int Request[100]={0};//请求资源向量
int temp[100]={0};//存放安全序列
int Work[100]={0};//存放系统可提供资源
int M=100;//作业的最大数为100
int N=100;//资源的最大数为100
void showdata()//显示资源矩阵
{
int i,j;
cout<<"系统目前可用的资源[Avaliable]:"<<endl;
for(i=0;i<N;i++)
cout<<name[i]<<" ";
cout<<endl;
for (j=0;j<N;j++)
cout<<Avaliable[j]<<" ";//输出分配资源
cout<<endl;
cout<<" Max Allocation Need"<<endl;
cout<<"进程名 ";
for(j=0;j<3;j++){
for(i=0;i<N;i++)
cout<<name[i]<<" ";
cout<<" ";
}
cout<<endl;
for(i=0;i<M;i++){
cout<<" "<<i<<" ";
for(j=0;j<N;j++)
cout<<Max[i][j]<<" ";
cout<<" ";
for(j=0;j<N;j++)
cout<<Allocation[i][j]<<" ";
cout<<" ";
for(j=0;j<N;j++)
cout<<Need[i][j]<<" ";
cout<<endl;
}
}

int changdata(int i)//进行资源分配
{
int j;
for (j=0;j<M;j++) {
Avaliable[j]=Avaliable[j]-Request[j];
Allocation[i][j]=Allocation[i][j]+Request[j];
Need[i][j]=Need[i][j]-Request[j];
}
return 1;
}
int safe()//安全性算法
{
int i,k=0,m,apply,Finish[100]={0};
int j;
int flag=0;
Work[0]=Avaliable[0];
Work[1]=Avaliable[1];
Work[2]=Avaliable[2];
for(i=0;i<M;i++){
apply=0;
for(j=0;j<N;j++){
if (Finish[i]==False&&Need[i][j]<=Work[j]){
apply++;
if(apply==N){
for(m=0;m<N;m++)
Work[m]=Work[m]+Allocation[i][m];//变分配数
Finish[i]=True;
temp[k]=i;
i=-1;
k++;
flag++;
}
}
}
}
for(i=0;i<M;i++){
if(Finish[i]==False){
cout<<"系统不安全"<<endl;//不成功系统不安全
return -1;
}
}
cout<<"系统是安全的!"<<endl;//如果安全，输出成功
cout<<"分配的序列:";
for(i=0;i<M;i++){//输出运行进程数组
cout<<temp[i];
if(i<M-1) cout<<"->";
}
cout<<endl;
return 0;
}
void share()//利用银行家算法对申请资源对进行判定
{
char ch;
int i=0,j=0;
ch='y';
cout<<"请输入要求分配的资源进程号(0-"<<M-1<<"):";
cin>>i;//输入须申请的资源号
cout<<"请输入进程 "<<i<<" 申请的资源:"<<endl;
for(j=0;j<N;j++)
{
cout<<name[j]<<":";
cin>>Request[j];//输入需要申请的资源
}
for (j=0;j<N;j++){
if(Request[j]>Need[i][j])//判断申请是否大于需求，若大于则出错
{
cout<<"进程 "<<i<<"申请的资源大于它需要的资源";
cout<<" 分配不合理，不予分配！"<<endl;
ch='n';
break;
}
else {
if(Request[j]>Avaliable[j])//判断申请是否大于当前资源，若大于则
{ //出错
cout<<"进程"<<i<<"申请的资源大于系统现在可利用的资源";
cout<<" 分配出错，不予分配!"<<endl;
ch='n';
break;
}
}
}
if(ch=='y') {
changdata(i);//根据进程需求量变换资源
showdata();//根据进程需求量显示变换后的资源
safe();//根据进程需求量进行银行家算法判断
}
}
void addresources(){//添加资源
int n,flag;
cout<<"请输入需要添加资源种类的数量:";
cin>>n;
flag=N;
N=N+n;
for(int i=0;i<n;i++){
cout<<"名称:";
cin>>name[flag];
cout<<"数量:";
cin>>Avaliable[flag++];
}
showdata();
safe();
}
void delresources(){//删除资源
char ming;
int i,flag=1;
cout<<"请输入需要删除的资源名称：";
do{
cin>>ming;
for(i=0;i<N;i++)
if(ming==name[i]){
flag=0;
break;
}
if(i==N)
cout<<"该资源名称不存在，请重新输入：";
}
while(flag);
for(int j=i;j<N-1;j++)
{
name[j]=name[j+1];
Avaliable[j]=Avaliable[j+1];

}
N=N-1;
showdata();
safe();
}
void changeresources(){//修改资源函数
cout<<"系统目前可用的资源[Avaliable]:"<<endl;
for(int i=0;i<N;i++)
cout<<name[i]<<":"<<Avaliable[i]<<endl;
cout<<"输入系统可用资源[Avaliable]:"<<endl;
cin>>Avaliable[0]>>Avaliable[1]>>Avaliable[2];
cout<<"经修改后的系统可用资源为"<<endl;
for (int k=0;k<N;k++)
cout<<name[k]<<":"<<Avaliable[k]<<endl;
showdata();
safe();
}
void addprocess(){//添加作业
int flag=M;
M=M+1;
cout<<"请输入该作业的最打需求量[Max]"<<endl;
for(int i=0;i<N;i++){
cout<<name[i]<<":";
cin>>Max[flag][i];
Need[flag][i]=Max[flag][i]-Allocation[flag][i];
}
showdata();
safe();
}
int main()//主函数
{

int i,j,number,choice,m,n,flag;
char ming;
cout<<"*****************资源管理系统的设计与实现*****************"<<endl;
cout<<"请首先输入系统可供资源种类的数量:";
cin>>n;
N=n;
for(i=0;i<n;i++)
{
cout<<"资源"<<i+1<<"的名称:";
cin>>ming;
name[i]=ming;
cout<<"资源的数量:";
cin>>number;
Avaliable[i]=number;
}
cout<<endl;
cout<<"请输入作业的数量:";
cin>>m;
M=m;
cout<<"请输入各进程的最大需求量("<<m<<"*"<<n<<"矩阵)[Max]:"<<endl;
for(i=0;i<m;i++)
for(j=0;j<n;j++)
cin>>Max[i][j];
do{
flag=0;
cout<<"请输入各进程已经申请的资源量("<<m<<"*"<<n<<"矩阵)[Allocation]:"<<endl;
for(i=0;i<m;i++)
for(j=0;j<n;j++){
cin>>Allocation[i][j];
if(Allocation[i][j]>Max[i][j])
flag=1;
Need[i][j]=Max[i][j]-Allocation[i][j];
}
if(flag)
cout<<"申请的资源大于最大需求量，请重新输入!\n";
}
while(flag);

showdata();//显示各种资源
safe();//用银行家算法判定系统是否安全
while(choice)
{
cout<<"**************银行家算法演示***************"<<endl;
cout<<" 1:增加资源 "<<endl;
cout<<" 2:删除资源 "<<endl;
cout<<" 3:修改资源 "<<endl;
cout<<" 4:分配资源 "<<endl;
cout<<" 5:增加作业 "<<endl;
cout<<" 0:离开 "<<endl;
cout<<"*******************************************"<<endl;
cout<<"请选择功能号：";
cin>>choice;
switch(choice)
{
case 1: addresources();break;
case 2: delresources();break;
case 3: changeresources();break;
case 4: share();break;
case 5: addprocess();break;
case 0: choice=0;break;
default: cout<<"请正确选择功能号(0-5)!"<<endl;break;
}
}
return 1;
}