银行家算法
‘壹’ 操作系统银行家算法
银行家算法是根据一个进程序列的请求试探性地分配资源给，即在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。
这里系统一步一步的试探性分配资源给每个进程，
对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量没有超过系统当前剩余资源量与所有进程Pj (j<i )当前占有资源量之和。
所以他是安全序列。
‘贰’ 银行家算法 C语言编程
1.根据下面给出的系统中资源分配情况，以及各个进程的资源申请情况，通过银行家算法来判断各进程的资源请求能否满足（要求记录程序的运行过程）。 已分配的
‘叁’ 什么是银行家算法
银行家算法是最有代表性的避免死锁算法，是Dijkstra提出的银行家算法。这是由于该算法能用于银行系统现金贷款的发放而得名。
银行家可以把一定数量的资金供多个用户周转使用,为保证资金的安全,银行家规定:
(1)当一个用户对资金的最大需求量不超过很行家现有的资金时可接纳该用户.
(2)用户可以分期贷款,但贷款的总数不能超过最大需求量;
(3)当银行家现有的资金不能满足用户的尚需总数时,对用户的贷款可推迟支付,但总能使用户在有限的时间里得到贷款;
(4)当用户得到所需的全部资金后,一定能在有限的时间里归还所有资金
银行家算法是通过动态地检测系统中资源分配情况和进程对资源的需求情况来决定如何分配资源的，在能确保系统处于安全状态时才能把资源分配给申请者，从而避免系统发生死锁。
要记住的一些变量的名称
1 Available（可利用资源总数）
某类可利用的资源数目，其初值是系统中所配置的该类全部可用资源数目。
2 Max：某个进程对某类资源的最大需求数
3 Allocation： 某类资源已分配给某进程的资源数。
4 Need：某个进程还需要的各类资源数。
Need= Max-Allocation
系统把进程请求的资源(Request)分配给它以后要修改的变量
Available:=Available-Request;
Allocation:=Allocation+Request;
Need:= Need- Request;
‘肆’ 计算机操作系统银行家算法
这个虚拟金币没得诱惑了，挂淘宝吧
‘伍’ 银行家算法
简介
银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源，但系银行家算法统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。为实现银行家算法，系统必须设置若干数据结构。 要解释银行家算法，必须先解释操作系统安全状态和不安全状态。 安全序列是指一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。
安全状态
如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。安全状态一定是没有死锁发生。
不安全状态
不存在一个安全序列。不安全状态不一定导致死锁。
[编辑本段]银行家算法的数据结构
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〕
[编辑本段]银行家算法原理：
我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。 为保证资金的安全,银行家规定: (1) 当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客; (2) 顾客可以分歧贷款,但贷款的总数不能超过最大需求量; (3) 当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款; (4) 当顾客得到所需的全部资金后,一定能在有限的时间里归还所有的资金. 操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。 运行平台：Windows XP VS2005 编程语言：C#
[编辑本段]算法的实现
初始化
由用户输入数据，分别对可利用资源向量矩阵AVAILABLE、最大需求矩阵MAX、分配矩阵ALLOCATION、需求矩阵NEED赋值。
银行家算法
在避免死锁的方法中，所施加的限制条件较弱，有可能获得令人满意的系统性能。在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发生死锁。 银行家算法的基本思想是分配资源之前,判断系统是否是安全的;若是,才分配。它是最具有代表性的避免死锁的算法。 设进程cusneed提出请求REQUEST [i]，则银行家算法按如下规则进行判断。 (1)如果REQUEST [cusneed] [i]<= NEED[cusneed][i]，则转(2)；否则，出错。 (2)如果REQUEST [cusneed] [i]<= AVAILABLE[cusneed][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+=ALLOCATION; Finish=true; GOTO 2 (4)如所有的进程Finish= true，则表示安全；否则系统不安全。
[编辑本段]算法
/// 资源数 public static int resourceNumber; /// 进程数 public static int processNumber; /// 可用资源数组 public static int[] Available; /// 工作向量 public static int[] work; /// 它表示系统是否有足够的资源分配给进程 public static bool[] Finish; /// 最大需求矩阵 public static int[][] Max; /// 分配矩阵 public static int[][] Allocation; /// 需求矩阵 public static int[][] Need; /// 安全序列 public static int[] SafeSequence; /// 资源请求向量 public static int[] Request; 算法思想： 主要是：递归+深度优先搜寻+回溯 算法源代码如下： /// 深搜+回溯实现银行家算法 /// <param name="n">已完成的进程数</param> public void DFS_searchSafeSequence(int n) { if (n == processNumber) { //找到一个安全序列,可以显示所有安全序列 //显示在richTextBoxshow.Text上 for (int i = 0; i < processNumber; i++) { richTextBoxshow.Text += SafeSequence[i] + " "; } richTextBoxshow.Text += "\n"; return; } for (int i = 0; i < processNumber; i++) { if (Finish[i] == false)//进程尚未完成 { //判断现有资源是否可以满足这个进程 bool isOK = true; for (int j = 0; j < resourceNumber; j++) { if (Need[i][j] > work[j]) { isOK = false; break; } } //可以满足 if (isOK) { //先试探的将资源分配给这个进程 for (int j = 0; j < resourceNumber; j++) { work[j] += Allocation[i][j]; } //已经完成 Finish[i] = true; //加入安全序列 SafeSequence[n] = i; //继续搜索 DFS_searchSafeSequence(n+1); //回溯 Finish[i] = false; SafeSequence[n] = -1; for (int j = 0; j < resourceNumber; j++) { work[j] -= Allocation[i][j];
‘陆’ 银行家算法(操作系统）
1、这是安全状态：
P1的需求小于可用资源数，先满足P1的请求，然后回收P1资源：可用资源变为 （3,3,2）＋（2,0,0）＝（5,3,2）；
这时P3可分配，P3结束后回收资源，可用资源为（5,3,2）＋（2,1,1）＝（7,4,3）
这时P0可分配，P0结束后回收资源，可用资源为（7,4,3）＋（0,1,0）＋（7,5,3）
接下来是P2，结束后可用资源为（7,5,3）＋（3,0,2）＝（10,5,5）
最后分配P4，结束后可用资源为（10,5,5）＋（0,0,2）＝（10,5,7）
这样得到一个安全序列：P1－P3－P0－P2－P4，所以T0状态是安全的。
2、T0时刻P1请求（1,1,2）<可用资源数（3,3,2），可以直接满足。
‘柒’ “银行家算法”是怎样的一个算法
银行家算法=-- -
1. 安全状态: 在某时刻系统中所有进程可以排列一个安全序列:{P1,P2,`````Pn},刚称此时,系统是安全的.
所谓安全序列{P1,P2,`````Pn}是指对于P2,都有它所需要剩余资源数量不大于系统掌握的剩余的空间资源与所有Pi(j<i)所占的资源之和.
2.不安全状态可能产生死锁.
目前状态 最大需求 尚需
P1 3 9 6
P2 5 10 5
P3 2 4 2
在每一次进程中申请的资源,判定一下,若实际分配的话,之后系统是否安全.
3.银行家算法的思路:
1),进程一开始向系统提出最大需求量.
2),进程每次提出新的需求(分期贷款)都统计是否超出它事先提出的最大需求量.
3),若正常,则判断该进程所需剩余剩余量(包括本次申请)是否超出系统所掌握的
剩余资源量,若不超出,则分配,否则等待.
4.银行家算法的数据结构.
1),系统剩余资源量A[n],其中A[n]表示第I类资源剩余量.
2),各进程最大需求量,B[m][n],其中B[j][i]表示进程j对i
类资源最大需求.
3),已分配资源量C[m][n],其中C[j][i]表示系统j程已得到的第i资源的数量.
4),剩余需求量.D[m][n],其中D[j][i]对第i资源尚需的数目.
5.银行家算法流程:当某时刻,某进程时,提出新的资源申请,系统作以下操作:
1),判定E[n]是否大于D[j][n],若大于,表示出错.
2),判定E[n]是否大于系统剩余量A[n],若大于,则该进程等待.
3),若以上两步没有问题,尝试分配,即各变量作调整.
4),按照安全性推测算法,判断,分配过后,系统是否安全,若安全,则实际分配,否则,撤消分配,让进程等待.
6."安全性检测"算法
1),先定义两个变量,用来表示推算过程的数据.
F[n]=A[n],表示推算过程中,系统中剩余资源量的变化.
J[n]=False表示推算过程中各进程是否假设"已完成"
2),流程:
在"剩余"的进程中(在推算)过程中,一些进程假设已完成,查找D[j][n]<=F[n]的进程,找到后令J[j]=True
(假设该进程完成),F[n]+D[j][n](该进程所占资源释放),如此循环执行.
若最后,所有的F[n]=True(在推算过程中,所有进程均可以完成),则表示(分配过后)系统是安全的,否则系统是不安全的.
参考资料：http://huangqiyu.blogchina.com/419807.html
‘捌’ 银行家算法题
兄弟，你题抄错了
‘玖’ 银行家算法C++描述
#include <iostream>
#include <string>
#define M 3 //资源的种类数
#define N 5 //进程的个数
void output(int iMax[N][M],int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]); //统一的输出格式
bool safety(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]);
bool banker(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]);
int main()
{
int i,j;
//当前可用每类资源的资源数
int iAvailable[M]={3,3,2};
//系统中N个进程中的每一个进程对M类资源的最大需求
int iMax[N][M]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};
//iNeed[N][M]每一个进程尚需的各类资源数
//iAllocation[N][M]为系统中每一类资源当前已分配给每一进程的资源数
int iNeed[N][M],iAllocation[N][M]={{0,1,1},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};
//进程名
char cName[N]={'a','b','c','d','e'};
bool bExitFlag=true; //退出标记
char ch; //接收选择是否继续提出申请时传进来的值
bool bSafe; //存放安全与否的标志
//计算iNeed[N][M]的值
for(i=0;i<N;i++)
for(j=0;j<M;j++)
iNeed[i][j]=iMax[i][j]-iAllocation[i][j];
//输出初始值
output(iMax,iAllocation,iNeed,iAvailable,cName);
//判断当前状态是否安全
bSafe=safety(iAllocation,iNeed,iAvailable,cName);
//是否继续提出申请
while(bExitFlag)
{
cout<<"\n"<<"继续提出申请？\ny为是；n为否。\n";
cin>>ch;
switch(ch)
{
case 'y':
//cout<<"调用银行家算法";
bSafe=banker(iAllocation,iNeed,iAvailable,cName);
if (bSafe) //安全，则输出变化后的数据
output(iMax,iAllocation,iNeed,iAvailable,cName);
break;
case 'n':
cout<<"退出。\n";
bExitFlag=false;
break;
default:
cout<<"输入有误，请重新输入：\n";
}
}
}
//输出
void output(int iMax[N][M],int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N])
{
int i,j;
cout<<"\n\t Max \tAllocation\t Need \t Available"<<endl;
cout<<"\tA B C\tA B C\tA B C\t A B C"<<endl;
for(i=0;i<N;i++)
{
cout<<cName[i]<<"\t";
for(j=0;j<M;j++)
cout<<iMax[i][j]<<" ";
cout<<"\t";
for(j=0;j<M;j++)
cout<<iAllocation[i][j]<<" ";
cout<<"\t";
for(j=0;j<M;j++)
cout<<iNeed[i][j]<<" ";
cout<<"\t";
cout<<" ";
//Available只需要输出一次
if (i==0)
for(j=0;j<M;j++)
cout<<iAvailable[j]<<" ";
cout<<endl;
}
}
//安全性算法，进行安全性检查；安全返回true，并且输出安全序列，不安全返回false，并输出不安全的提示；
bool safety(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N])
{
}
//定位ch对应的进程名在数组中的位置
//没找见返回－1，否则返回数组下标
int locate(char cName[N],char ch)
{
int i;
for(i=0;i<N;i++)
if (cName[i]==ch) //找到
return i;
//未找到
return -1;
}
//提出申请,返回提出申请的进程名对应的下标
int request(char cName[N],int iRequest[M])
{
int i,loc;
char ch;
bool bFlag=true;
//判断输入的进程名是否有误
while(bFlag)
{
//输出进程名
for(i=0;i<N;i++)
cout<<cName[i]<<"\t";
//输入提出申请的进程名
cout<<"\n输入提出资源申请的进程名：\n";
cin>>ch;
//定位ch对应的进程名在进程名数组中的位置
loc=locate(cName,ch);
//没找到，重新输入
if (loc==-1)
cout<<"\n您输入的进程名有误！请重新输入";
//找到，退出循环
else
bFlag=false;
}
//输入提出申请的资源数
cout<<"输入申请各类资源的数量：\n";
for(i=0;i<M;i++)
cin>>iRequest[i];
//返回提出申请的进程名对应的下标
return loc;
}
bool banker(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N])
{
}
这个是c++的 我的报告