银行家算法例题
计算机操作系统之银行家算法
淮海工学院计算机工程学院实验报告书课程名：《计算机操作系统》题目：实验二银行家算法班级： ^ ^ 姓名： ^ ^实验二银行家算法实验目的和要求应用银行家算法验证进程安全性检查及分配资源编制模拟银行家算法的程序，并以以下例子验证程序的正确性。
实验环境1．PC微机。
2．Windows 操作系统。
3．C/C++/VB开发集成环境。
实验学时2学时，必做实验实验内容和步骤1）依照算法流程图编制可执行程序2）用以下两个例子验证程序的正确性。
3）按照上述两个例子，输出执行的结果。
算法流程图银行家算法：安全性算法：【例1】某系统有A、B、C、D这4类资源供5个进程共享，进程对资源的需求和分配情况如下表所示。
现在系统中A、B、C、D类资源分不还剩1、5、2、0个，请按银行家算法回答下列问题：(1) 现在系统是否处于安全状态?(2) 假如现在进程P2提出需要(0，4，2，0)个资源的请求，系统能否满足它的请求？【例2】用银行家算法考虑下列系统状态：进程分配矩阵最大需求矩阵资源总数矩阵A 3 0 1 1 4 1 1 16 3 4 2B 0 1 0 0 0 2 1 2C 1 1 1 0 4 2 1 0D 1 1 0 1 1 1 1 1E 0 0 0 0 2 1 1 0问系统是否安全？若进程B请求(0,0,1,0)，可否立即分配？此后进程E也请求(0,0,1,0)，可否分配给它？通过运行程序发觉，例1当中的系统处于不安全状态，进程P2提出的请求无法实现；例2当中的系统处于安全状态，进程B提出的请求能实现，此后进程E的请求也能实现。
源代码#include<iostream>#define N 20#define M 20using namespace std;int f(int a[N][M],int b[N][M],int m,int k) {int j;for(j=0;j<m;j++)if(a[k-1][j]>b[k-1][j])return 0;return 1;}int g(int a[N][M],int b[],int m,int k) {int j;for(j=0;j<m;j++)if(a[k][j]>b[j])return 0;return 1;}int h(int a[],int n){for(int i=0;i<n;i++)if(!a[i])return 0;return 1;}int p(int a[],int b[N][M],int m,int k){int j;for(j=0;j<m;j++)if(a[j]>b[k-1][j])return 0;return 1;}int q(int a[],int b[],int m){int j;for(j=0;j<m;j++)if(a[j]>b[j])return 0;return 1;}int safe(int Finish[N],int Work[M],int Need[N][M],int Allocation[N][M],int n,int m){ int i,j,k;int t[N];for(i=0;i<n;i++)t[i]=1;cout<<"安全性检查!"<<endl;for(i=0;i<n;)// 首先找到一个满足条件的进程 {if((Finish[i]==0)&&g(Need,Work,m,i)){k=i;t[i]=0;cout<<"p("<<k+1<<"):"<<endl;cout<<"Work["<<m<<"]:";for(j=0;j<m;j++){cout<<Work[j]<<" ";Work[j]=Work[j]+Allocation[i][j]; Finish[i]=1;}cout<<endl;cout<<"Need["<<m<<"]:";for(j=0;j<m;j++)cout<<Need[i][j]<<" ";cout<<endl;cout<<"Allocation["<<m<<"]:";for(j=0;j<m;j++)cout<<Allocation[i][j]<<" ";cout<<endl;cout<<"(Work+Allocation)["<<m<<"]:"; for(j=0;j<m;j++)cout<<Work[j]<<" ";cout<<endl;cout<<"Finish["<<k+1<<"]:";cout<<Finish[i]<<" ";cout<<endl;break;}else{i++;}}if(g(Need,Work,m,k))//依次找到满足条件的后面几个进程 {for(i=0;i<n;i++){if(t[i]){if(g(Need,Work,m,i)){cout<<"p("<<i+1<<"):"<<endl;cout<<"Work["<<m<<"]:";for(j=0;j<m;j++){cout<<Work[j]<<" ";Work[j]=Work[j]+Allocation[i][j];Finish[i]=1;cout<<endl;cout<<"Need["<<m<<"]:";for(j=0;j<m;j++)cout<<Need[i][j]<<" ";cout<<endl;cout<<"Allocation["<<m<<"]:";for(j=0;j<m;j++)cout<<Allocation[i][j]<<" ";cout<<endl;cout<<"(Work+Allocation)["<<m<<"]:"; for(j=0;j<m;j++)cout<<Work[j]<<" ";cout<<endl;cout<<"Finish["<<i+1<<"]:";cout<<Finish[i]<<" ";cout<<endl;t[i]=0;}}}else {return 0;}if(h(Finish,n))return 1;//系统处于安全状态else return 0;//系统处于不安全状态}void r(int Finish[N],int Work[M],int Available[M],int Need[N][M],int Allocation[N][M],int Max[N][M],int n,int m) {int Request[M];char b;int i,j,k;cout<<"\n要申请资源，请按'y'或'Y'，否则按'n'或'N'"<<endl;//是立即进行安全性检查，依旧进行资源申请cin>>b;if(b!='y'&&b!='Y')if(safe(Finish,Work,Need,Allocation,n,m)){cout<<"现在刻系统安全!\n";}else{cout<<"现在刻系统不安全!\n";}}else{{cout<<"\n请输入申请资源的进程编号(1,2,…,"<<n<<"):"<<endl;cin>>k;while(k>n){cout<<"您输入了错误的进程号,请核查后重新输入:"<<endl;cin>>k;}cout<<"\n请输入进程p("<<k<<")申请各类资源的数量:"<<endl;for (j=0; j<m; j++)cin>>Request[j];if(p(Request,Need,m,k)){if(q(Request,Available,m)){for(j=0;j<m;j++){Available[j]=Available[j]-Request[j];Allocation[k-1][j]=Allocation[k-1][j]+Request[j]; Need[k-1][j]=Need[k-1][j]-Request[j];Work[j]=Available[j];}cout<<"试分配!"<<endl;cout<<"各种资源可利用的数量Available["<<m<<"]: "<<endl;for (j=0; j<m; j++){cout<<Available[j]<<" ";}cout<<endl;cout<<"\n已分配资源Allocation["<<m<<"]: "<<endl;for (i=0; i<n; i++){for (j=0; j<m; j++){cout<<Allocation[i][j]<<" ";}cout<<endl;}cout<<"\n最大需求矩阵Max["<<n<<"]["<<m<<"]: "<<endl; for (i=0; i<n; i++){for (j=0; j<m; j++){cout<<Max[i][j]<<" ";}cout<<endl;}cout<<"\n需求矩阵Need["<<n<<"]["<<m<<"]: "<<endl; for (i=0; i<n; i++){for (j=0; j<m; j++){cout<<Need[i][j]<<" ";}cout<<endl;}if (safe(Finish,Work,Need,Allocation,n,m)){//推断当前状态的安全性cout<<"系统处于安全状态!";cout<<"\n申请资源成功!!!"<<endl;}else{cout<<"\n当前状态不安全!!!!!!";//恢复数据for (j=0; j<m; j++){Available[j]=Available[j]+Request[j];Allocation[k-1][j]=Allocation[k-1][j]-Request[j];Need[k-1][j]=Need[k-1][j]+Request[j];Work[j]=Available[j];}for(i=0; i<n; i++)Finish[i]=0;cout<<"\n恢复数据："<<endl;//显示输入各数组的值cout<<"各种资源可利用的数量Available["<<m<<"]: "<<endl;for (j=0; j<m; j++){cout<<Available[j]<<" ";}cout<<endl;cout<<"\n已分配资源Allocation["<<m<<"]: "<<endl;for (i=0; i<n; i++){for (j=0; j<m; j++){cout<<Allocation[i][j]<<" ";}cout<<endl;}cout<<"\n最大需求矩阵Max["<<n<<"]["<<m<<"]: "<<endl; for (i=0; i<n; i++){for (j=0; j<m; j++){cout<<Max[i][j]<<" ";}cout<<endl;}cout<<"\n需求矩阵Need["<<n<<"]["<<m<<"]: "<<endl; for (i=0; i<n; i++){for (j=0; j<m; j++){cout<<Need[i][j]<<" ";}cout<<endl;}cout<<"系统中尚无足够的资源满足进程p["<<k<<"]的申请,p["<<k<<"]必须等待!"<<endl;}}else cout<<"系统中尚无足够的资源满足进程p["<<k<<"]的申请,p["<<k<<"]必须等待!"<<endl;}else cout<<"出错,进程所需要的资源数目已超过它所宣布的最大值!"<<endl;}}}void main(){cout<<"---------------------------------------------------------"<<endl;cout<<"------------------模拟银行家算法------------------"<<endl;cout<<"---------------------------------------------------------"<<endl;cout<<"--------------------江之风海之韵-------------------"<<endl;cout<<"------------------------QuQu-------------------------"<<endl;cout<<"---------------------------------------------------------"<<endl;int Available[M];int Max[N][M];int Allocation[N][M];int Need[N][M];int Work[M];int Finish[N];int i,j,n,m;//定义全局变量cout<<"输入进程的数量: ";//从此开始输入有关数据cin>>n;cout<<"输入资源种类数: ";cin>>m;cout<<"输入各种资源可利用的数量Available["<<m<<"]: "<<endl;for (j=0; j<m; j++){cin>>Available[j];Work[j]=Available[j];//初始化Work[j]}cout<<"\n输入各进程对各类资源的最大需求数Max["<<n<<"]["<<m<<"]: "<<endl;cout<<"\n请严格按照("<<n<<"×"<<m<<")的距阵输入:"<<endl;for (i=0; i<n; i++){for (j=0; j<m; j++)cin>>Max[i][j];}cout<<"\n请输入各进程当前已分配的资源数量Allocation["<<n<<"]["<<m<<"]: "<<endl;cout<<"\n请严格按照("<<n<<"×"<<m<<")的距阵输入:"<<endl; for (i=0; i<n; i++){for (j=0; j<m; j++){cin>>Allocation[i][j];Need[i][j] = Max[i][j]-Allocation[i][j];}}r(Finish,Work,Available,Need,Allocation,Max,n,m); for(i=0;i<n;i++)Finish[i]=0;r(Finish,Work,Available,Need,Allocation,Max,n,m); for(i=0;i<n;i++)Finish[i]=0;r(Finish,Work,Available,Need,Allocation,Max,n,m); for(i=0;i<n;i++)Finish[i]=0;r(Finish,Work,Available,Need,Allocation,Max,n,m); for(i=0;i<n;i++)}实验结果实验体会银行家算法在计算机操作系统中是一个特不重要的算法，这次我编制模拟银行家算法的程序，来验证了程序的正确性。
银行家算法习题1
银行家算法流程安全性算法流程图银行家算法例题 1.假定系统中有4个进程1P ，2P ，3P ，4P ， 3种类型的资源1R ，2R ，3R ，数量分别为9,3,6， 0T 时刻的资源分配情况如表2-1所示。
表2-1 T 0时刻的资源分配情况试问:(1) T 0时刻是否安全？(2) T 0时刻以后，若进程P 2发出资源请求Request 2(1,0,1), 系统能否将资源分配给它？ (3) 在进程P 2申请资源后，若P1发出资源请求Request 1(1,0,1), 系统能否将资源分配给它？(4) 在进程P 1申请资源后，若P3发出资源请求Request 3(0,0,1), 系统能否将资源分配给它？2. 在银行家算法中，出现以下资源分配情况（见表2-2）系统剩余资源数量=(3,3,2)(1) 该状态是否安全（给出详细的检查过程） (2) 如果进程依次有如下资源请求：P1：资源请求request （1,0,2） P2：资源请求request （3,3,0） P3：资源请求request （0,1,0）则系统该如何进行资源分配才能避免死锁？3.设系统中有3种类型的资源（A、B、C）和5个进程P1、P2、P3、P4、P5，A资源的数量为17，B资源的数量为5，C资源的数量为20。
在T0时刻，系统状态见表2-3。
系统采用银行家算法实现死锁避免。
(1)T0时刻是否为安全状态？若是，请给出安全序列(2)在T0时刻，若进程P2请求资源（0,3,4），是否能实施资源分配？为什么？(3)在（2）的基础上，若进程P4请求资源（2,0,1），是否能实施资源分配？(4)在（3）的基础上，若进程P1请求资源（0,2,0），是否能实施资源分配？4．某系统有R1、R2、R3共三种资源，在T0时刻P1、P2、P3、P4这四个进程对资源的占用和需求情况见表2-24，此时系统的可用资源矢量为（2，1，2）。
试问：1）将系统中各种资源总数和此刻各进程对各资源的需求数目用矢量或矩阵表示出来。
银行家算法典型例题
银行家算法典型例题银行家算法是一种死锁避免策略，适用于系统中有多个进程和多种资源的情况。
在该算法中，每个进程需要预先声明其最大资源需求和当前已经分配的资源数量，同时系统也需要知道每种资源的总数量和已经分配的数量。
通过比较每个进程的资源需求和系统当前可用资源数量，可以判断系统是否处于安全状态，以及是否能够分配资源给某个进程。
在本例中，系统中有3种资源A、B、C，分别有10、5、7个。
同时有5个进程P0至P4，它们的最大资源需求和已分配资源情况如下表所示。
在T0时刻，系统状态如表所示。
根据银行家算法，我们可以回答以下问题：1) 在T0时刻，系统处于安全状态，安全序列为P1、P3、P4、P2、P0.2) 若进程P1在T0时刻发出资源请求Request(1,0,2)，则可以实施资源分配。
因为该请求的资源需求小于进程P1的最大需求，且系统当前可用资源数量足够满足该请求。
3) 在P1请求资源之后，若进程P4发出资源请求Request(3,3,0)，则无法实施资源分配。
因为该请求的资源需求大于进程P4的最大需求，且系统当前可用资源数量不足以满足该请求。
因此，P4需要等待其他进程释放资源后再尝试请求。
4) 在P1请求资源之后，若进程P0发出资源请求Request(0,2,0)，则可以实施资源分配。
因为该请求的资源需求小于进程P0的最大需求，且系统当前可用资源数量足够满足该请求。
Process n Need AvailableP0 0 3 20 0 1 21 6 2 2P1 1 0 01 7 5 0P2 1 2 2 3 5 6P3 3 3 20 6 5 2P4 0 1 40 6 5 6n: (1) Is the system in a safe state。
(2) If process P2 requests (1,2,2,2)。
can the system allocate the resources to it?Answer: (1) Using the safety algorithm。
（完整word版）银行家算法例题
（完整word版）银行家算法例题银行家算法例题假定系统中有五个进程{P0，P1，P2，P3，P4} 和三类资源{A ，B,C},各种资源的数量分别为10、5、7，在T0 时刻的资源分配情况（1）T0时刻的安全性利用安全性算法对T0时刻的资源分配情况进行分析（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向量，由此形成资源情况进程Max Allocation Need Available A B C A B C A B C A B C P0 7 5 3 0 1 0 7 4 3 3 3 2 P1 3 2 2 2 0 0 1 2 2 P2 9 0 2 3 0 2 6 0 0 P3 2 2 2 2 1 1 0 1 1 P44 3 30 0 24 3 1资源情况进程Work A B C Need A B C Allocation A B CWork+Allocatio n A B C FinishP1 3 3 2 1 2 2 2 0 0 5 3 2 TRUE P3 5 3 2 0 1 1 2 1 1 7 4 3 TRUE P4 7 4 3 4 3 1 0 0 2 7 4 5TRUE P2 7 4 5 6 0 0 3 0 2 10 4 7 TRUE P010 4 77 4 30 1 010 5 7的资源变化情况如下图所示。
④再利用安全性算法检查此时系统是否安全。
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个资源类型（A、B、C、D），每个资源类型的数量分别为10、5、7和8、现在有5个进程（P0、P1、P2、P3、P4）需要申请资源，并且已经获得了一些资源。
他们的资源需求和现有资源分别如下：进程，已分配的资源（A/B/C/D），需要的资源（A/B/C/D）-----，-----------------------，-----------------------P0，0/1/0/3，7/5/3/3P1，2/0/0/0，0/0/2/2P2，3/0/2/0，9/0/2/2P3，2/1/1/0，2/2/2/2P4，0/0/2/1，4/3/3/4银行家算法的目标是判断当前系统状态是否是安全的，即是否存在一种资源分配序列，使得所有进程能够顺利执行并完成。
银行家算法的具体步骤如下：1.遍历所有进程，检查每个进程尚未满足的资源需求是否小于等于当前系统中尚未分配的资源。
如果有任何一个进程的需求超过可用资源，说明系统状态不安全，算法终止。
2.如果所有进程的需求都满足，将当前系统的剩余资源和每个进程尚未分配的资源相加，得到一个临时的系统状态。
3.重新遍历所有进程，检查每个进程的需求是否小于等于临时系统状态中对应资源的总量。
如果有任何一个进程的需求超过临时系统资源，说明系统状态不安全，算法终止。
4.如果所有进程的需求都满足，将这些资源分配给对应进程，并更新系统状态。
5.重复步骤2至4，直到所有进程的需求都得到满足，或者无法继续分配资源。
在以上例子中，银行家算法首先检查每个进程的需求是否小于等于系统中可用的资源。
如果系统中尚有足够的资源，会将这些资源分配给对应进程，并从系统中减去已分配的资源。
在本例中，P0需要的资源(7/5/3/3)小于系统中可用的资源(10/5/7/8)，因此可以将资源分配给P0，并更新系统状态为(7/4/7/8)。
银行家算法例子+答案
1、设系统中有3种类型的资源（A ，B ，C ）和5个进程P1、P2、P3、P4、P5，A 资源的数量为17，B 资源的数量为5，C 资源的数量为20。
在T 0时刻系统状态见下表（T 0时刻系统状态表）所示。
系统采用银行家算法实施死锁避免策略。
（12分）T 0时刻系统状态表(1)T 0时刻是否为安全状态？若是，请给出安全序列。
(2)在T 0时刻若进程P2请求资源（0，3，4），是否能实施资源分配？为什么？(3)在（2）的基础上，若进程P4请求资源（2，0，1），是否能实施资源分配？为什么？(4)在（3）的基础上，若进程P1请求资源（0，2，0），是否能实施资源分配？为什么？答：当前的系统状态描述为：⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡=4245241104635955C ⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡=413402504204212A ⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡=-011122600431743A C ()20517=R()332=V（1）在T0时刻，由于V （2，3，3）大于等于（C-A ）中P5所在行的向量（1，1，0），因此V 能满足P5的运行，在P5运行后，系统的状态为：⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡=000402504204212A ⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡=-000122600431743A C ()745'=V 同样的，在P5运行后，V ’（5，4，7）也大于等于C-A 中P4所在的行（2，2，1），则能满足P4的运行。
P4运行后，系统的状态为：⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡=000000504204212A ⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡=-000000600431743A C ()1147'=V 按照上述同样的方法，P4运行后，P3，P2，P1也能按顺序运行。
（备注：考试时需要都写出来）。
因此，在T0时刻，存在安全序列：P5、P4、P3、P2、P1。
银行家算法习题
假设一家银行拥有资金20**万，现有10家公司向其贷款进行筹建，每家均需300万才能建成。
如果这家银行将20**万的资金平均贷给这10家公司，则每家公司将得到200万的贷款，都不能筹建成功，也就不能还贷，那么这10家公司都将“死锁”。
若这家银行给其中的4家各贷300万，另4家各贷200万，这样将还有2家公司得不到贷款，不能开工建设，但有4家可筹建完成，这4家公司运营所得利润可向该银行还贷，银行可以利用还贷的资金继续向其他的公司贷款，从而保证所有公司筹建成功投入运营。
银行家算法是为了把一定数量的资金供多个用户周转，并保证资金的安全。
银行家算法可归纳为：（1）当一个用户对资金的最大需求量不超过银行家现有的资金时，就可接纳该用户。
（2）用户可以分期贷款，但贷款总数不能超过最大需求量。
（3）当银行家现有的资金不能满足用户的尚需贷款数时，可以推迟支付，但总能使用户在有限的时间里得到贷款。
（4）当用户得到所需的全部资金后，一定能在有限时间里归还所有的资金。
我们可以把操作系统看作银行家，把进程看作用户，把操作系统管理的资源看作银行家管理的资金，把进程向操作系统请求资源看作用户向银行家贷款。
操作系统按照银行家规定的规则为进程分配资源。
当进程首次申请资源时，要测试该进程对资源的最大需求量。
如果系统现存的资源可以满足它的最大需求量，则按当前的申请量分配资源，否则推后分配。
当进程在执行中继续申请资源时，先测试该进程已占有的资源数与本次申请的资源数之和是否超过该进程对资源的最大需求量。
如果超过，则拒绝分配资源，否则再测试系统现存的资源能否满足该进程尚需的最大资源量。
若能满足，则按当前的申请量分配资源，否则也要推迟分配。
这样做，能保证在任何时刻至少有一个进程可以得到所需要的全部资源而执行到结束，执行结束后归还资源，并把这些资源加入到系统的剩余资源中，用同样的方法为其他的进程分配资源。
银行家算法的数据结构包括：（1）可用资源向量Available。
用银行家算法考虑下
1.用银行家算法考虑下列系统状态：进程分配矩阵最大需求矩阵资源总数向量A 3 0 1 1 4 1 1 1 6 3 4 2B 0 1 0 0 0 2 1 2C 1 1 1 0 4 2 1 0D 1 1 0 1 1 1 1 1E 0 0 0 0 2 1 1 0问：(1) 系统是否安全？（应说明理由）(2) 若进程B请求(0,0,1,0)，可否立即分配？请分析说明。
(3) 此后进程E也请求(0,0,1,0)，可否分配给它？请分析说明。
解：(1) 由已知条件可得Need和Avaiable矩阵如下：进程分配矩阵尚需矩阵(Need) 可用资源数向量(Avaiable)A 3 0 1 1 1 1 0 0 1 0 2 0B 0 1 0 0 0 1 1 2C 1 1 1 0 3 1 0 0D 1 1 0 1 0 0 1 0E 0 0 0 0 2 1 1 0利用银行家算法对此时刻的资源分配情况进行分析如下表：从上述分析可知，存在一个安全序列D，A，B，C，E，故当前系统是安全的。
（2）若进程B请求(0,0,1,0)，试分配并修改相应的数据结构，则系统状态变为：进程分配矩阵尚需矩阵(Need) 可用资源数向量(Avaiable)A 3 0 1 1 1 1 0 0 1 0 1 0B 0 1 1 0 0 1 0 2C 1 1 1 0 3 1 0 0D 1 1 0 1 0 0 1 0E 0 0 0 0 2 1 1 0利用银行家算法对此时刻的资源分配情况进行分析如下表：从上述分析可知，存在安全序列D，A，B，C，E，故系统仍是安全的，因此可以立即分配。
（3）此后进程E也请求(0,0,1,0)，则系统状态变为：进程分配矩阵尚需矩阵(Need) 可用资源数向量(Avaiable)A 3 0 1 1 1 1 0 0 1 0 0 0B 0 1 1 0 0 1 0 2C 1 1 1 0 3 1 0 0D 1 1 0 1 0 0 1 0E 0 0 1 0 2 1 0 0此时系统剩余资源（1，0，0，0）已不能满足任何进程的需求，即已找不到一个安全序列，系统状态将变为不安全，故不能分配给E。
银行家算法解决死锁
银行家算法解决死锁问题1、设系统中有3种类型的资源（A，B，C）和5个进程P1、P2、P3、P4、P5，A资源的数量为17，B资源的数量为5，C资源的数量为20。
在T0时刻系统状态见下表（T0时刻系统状态表）所示。
系统采用银行家算法实施死锁避免策略。
（12分）T0时刻系统状态表T0时刻系统状态表P2请求资源（0，3，4）（0，1，1）(1)T0时刻是否为安全状态？若是，请给出安全序列。
(2)在T0时刻若进程P2请求资源（0，3，4），是否能实施资源分配？为什么？(3)在（2）的基础上，若进程P4请求资源（2，0，1），是否能实施资源分配？为什么？(4)在（3）的基础上，若进程P1请求资源（0，2，0），是否能实施资源分配？为什么？答：当前的系统状态描述为：⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡=4245241104635955C //资源最大需求数量 max ⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡=413402504204212A //已分配资源数量 alloc⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡=-011122600431743A C //还需资源数量 Need()20517=R //资源总量 ()332=V //系统可用资源向量（1）T 0时刻是否为安全状态？若是，请给出安全序列。
在T0时刻，由于V （2，3，3）大于等于（C-A ）中P5所在行的向量（1，1，0），因此V 能满足P5的运行，在P5运行后，系统的状态为：⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡=000402504204212A ⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡=-000122600431743A C ()745'=V同样的，在P5运行后，V’（5，4，7）也大于等于C-A 中P4所在的行（2，2，1），则能满足P4的运行。
P4运行后，系统的状态为：⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡=000000504204212A ⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡=-000000600431743A C ()1147'=V按照上述同样的方法，P4运行后，P3，P2，P1也能按顺序运行。
银行家算法问题
银行家算法问题1、银行家算法中的数据结构（1）可利用资源向量Available：[]=Availabel j k式中：j01≤≤-j m一个含有m个（类）元素的数组，每个元素代表一类可利用的资源数目。
上式表示系统中现有的第j类资源可用数目为k个。
（2）最大需求矩阵Max：[,]=Max i j k式中：i01≤≤-i nj01≤≤-j mn个进程中的每一个进程对m类资源的最大需求量，上式表示进程i需求第j 类资源的最大数目为k。
（3）分配矩阵Allocation：[,]=Allocation i j k式中：i01≤≤-i nj01≤≤-j mn个进程中的每一个进程对m类资源的分配量，上式表示进程i已分配到第j 类资源的数目为k。
（4）需求矩阵Need：[,]=Need i j k式中：i01≤≤-i nj01≤≤-j mn 个进程中的每一个进程对m 类资源的需求量，上式表示进程i 对第j 类资源的需求量为k 个。
（5）三个矩阵间的关系[,][,][,]Need i j Max i j Allocation i j =-2、银行家算法设Re i quest 是进程i P 的请求向量，如果Re []i quest j k =，当i P 发出资源请求后，系统按下述步骤进行检查。
（1）如果Re [][,]i quest j Need i j ≤，便转向步骤（2），否则认为出错，因为它所需要的资源数已超过它所宣布的最大值。
（2）如果Re [][]i quest j Available j ≤便转向步骤（3），否则表示尚无足够资源，i P 须等待。
（3）系统试探着把资源分配给进程i P ，并修改下面的数据结构中的值：[][]Re []i Availabel j Availabel j quest j =-[,][,]Re []i Allocation i j Allocation i j quest j =+[,][,]Re []i Need i j Need i j quest j =-（4）系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。
银行家算法
书本例题：P ７０
三、(10分) 资源总量为10。
三个进程A、B、C的最大资源需求
量分别是9、4、7，如图(a)所示。
若干次请求后，资源使用情况如图(b)所示。
现
在进程B提出一个资源请求，系统可接受该请求吗？请用银行家算法进行测试，
做出判断。
解答：
如果在图(b)时接受进程B的一个资源请求，它所导致的图(c)的状态是安全的，系统可以放心地接受这次资源申请。
三、(10分) 在银行家算法中，若出现下述的资源分配情况：
Process Allocation Need Available
p0 1,0,2,3 7,6,6,1 3,0,1,4
p1 2,1,0,1 6,6,5,7
p2 1,0,4,1 3,5,1,5
p3 0,3,2,1 3,1,2,8
p4 3,2,1,0 3,2,2,5
p5 0,1,2,6 2,0,1,2
试问该状态是否安全？（要求写出判断过程）
一、（共10分）
安全（2分），因为：
进程⇒Available的变化
p5⇒3,1,3,10
p3⇒3,4,5,11
p4⇒6,6,6,11
p1⇒8,7,6,12
p0⇒9,7,8,15
p2⇒10,7,12,16（8分）。
银行家算法案例
银行家算法案例银行家算法是一种资源分配方法，最早由美国银行家在20世纪中期提出。
该算法主要用于解决银行系统中的资源冲突问题，保证系统能够正常运行并避免死锁的发生。
银行家算法的核心思想是通过对系统中的资源进行合理分配，避免资源的浪费和重复使用，从而实现最优的资源利用效益。
该算法能够预测系统在不同情况下的资源需求量，并根据需求情况作出相应的分配策略。
为了更好地理解银行家算法的原理和应用，我们来看一个具体的案例。
假设有一个银行系统，共有3个客户（A、B、C）和3类资源（R1、R2、R3）。
每个客户都有自己的资源需求量和拥有资源数。
我们的目标是分配资源以满足每个客户的需求，并确保系统的资源利用效率最大化。
以下是每个客户的资源情况：客户A：资源需求量（2，0，1），拥有资源数（1，1，2）客户B：资源需求量（1，1，0），拥有资源数（2，0，0）客户C：资源需求量（1，2，1），拥有资源数（1，1，2）现在，我们使用银行家算法来分配资源。
首先，系统分配资源给客户A，由于系统中还有足够的资源满足A的需求，所以分配是安全的。
接下来，系统尝试分配资源给客户B，但发现系统中的资源不足以满足B的需求，所以暂时无法满足B的请求。
然后，系统尝试分配资源给客户C，同样发现系统中的资源不足以满足C的需求，所以也无法满足C的请求。
现在，系统重新调整资源分配情况，将原本分配给A的资源收回，以备将来满足更多客户的需求。
接着，系统重新尝试分配资源给客户B，发现此时系统中剩余的资源可以满足B的需求，所以分配是安全的。
最后，系统再次尝试分配资源给客户C，发现此时系统中还有足够的资源满足C的需求，所以也是安全的。
通过以上分配过程，我们可以得出如下结论：1. 银行家算法能够根据系统的资源情况，预测不同客户的资源需求量，并进行安全的分配。
2. 在资源有限的情况下，银行家算法可以帮助我们合理分配资源，避免资源的浪费和重复使用。
3. 银行家算法的应用能够最大化系统的资源利用效益，确保系统的稳定运行。
银行家算法
银行家算法(进程需求的资源数≤剩余的资源数才是安全序列)例题:系统中有4种类型的资源（A、B、C、D）和5个进程P1、P2、P3、P4和P5, A资源的数量为3, B资源的数量为12, C资源的数量为14, D资源的数量为14,在某时刻系统状态如下表所示,系统采用银行家算法实施死锁避免策略.资源分配表下列进程执行序列中,哪些不是安全序列( )A:P1 P4 P5 P2 P3 B:P1 P4 P2 P5 P3 C:P1 P4 P3 P2 P5 D:P1 P3 P4 P5 P2E:P1 P5 P4 P3 P2 解题步骤:①,我们要根据题干计算出剩余资源数量,(有的题目直接给出了剩余资源数量,我们就不需要计算了.), 剩余资源数量＝资源的数量－已分配资源数量,根据题目计算得出, A资源的数量为3减去A已分配资源数量2等于1,B资源的数量为12减去B已分配资源数量6等于6C资源的数量为14减去C已分配资源数量12等于2D资源的数量为14减去D已分配资源数量12等于2求出剩余资源数量( A 1 B 6 C 2 D 2 )②,我们要计算出需求资源数量,(相应进程的ABCD互减, A减A ,B减B, C减C, D减D )③根据剩余资源数量来判断执行序列的安全,进程需求的资源数≤剩余的资源数才是安全序列(也就是说,剩余资源数量≥需求资源数量,才安全)采用银行家算法,每次执行完一个进程需要加上此进程的已分配资源数量,再执行下一个进程,以此类推.④我们来看选项A:P1 P4 P5 P2 P3, 我们之前求出剩余资源数量( A 1 B 6 C 2 D 2 )此刻, 剩余资源数量( A 1 B 6 C 2 D 2 )各个资源都大于,P1进程需求资源数量为(A 0、 B 0、 C 1、 D 2 )(1、6、2、2)＞(0、0、1、2),安全,运行完P1进程后,剩余资源数量需要加上P1进程已分配资源数量,即: (1、6、2、2)＋(0、0、3、2)＝(1、6、5、4),接下来执行P4进程,此时已经运行完P1进程,所以此刻剩余资源数量为(1、6、5、4),(1、6、5、4)各项资源数量≥P4进程需求的资源数量(0、6、5、2),安全运行完P4进程后,剩余资源数量需要加上P4进程已分配资源数量,即:(1、6、5、4) ＋(0、3、3、2) ＝(1、9、8、6), 接下来执行P5进程,P5进程需求的资源数量为(0、6、5、6)此时已经运行完P4进程,所以此刻剩余资源数量为(1、9、8、6)(1、9、8、6) 各项资源数量≥P5进程需求的资源数量(0、6、5、6),安全运行完P5进程后,剩余资源数量需要加上P5进程已分配资源数量,即:(1、9、8、6) ＋(0、0、1、4)＝(1、9、9、10), 接下来执行P2进程,P2进程需求的资源数量为(1、7、5、0)此时已经运行完P5进程,所以此刻剩余资源数量为(1、9、9、10),(1、9、9、10), 各项资源数量≥P2进程需求的资源数量(1、7、5、0),安全运行完P2进程后,剩余资源数量需要加上P2进程已分配资源数量,即:(1、9、9、10) ＋(1、0、0、0) ＝(2、9、9、10),接下来执行P3进程此时已经运行完P2进程,所以此刻剩余资源数量为(2、9、9、10)(2、9、9、10) 各项资源数量≥P3进程需求的资源数量(2、3、5、6),安全此时5个进程运行完毕所以选项A:P1 P4 P5 P2 P3,执行序列正确.,同理选项B:P1 P4 P2 P5 P3执行序列正确⑤们分析一下选项C为啥不正确,我们来看选项, C:P1 P4 P3 P2 P5 我们之前求出剩余资源数量( A 1 B 6 C 2 D 2 )此刻, 剩余资源数量( A 1 B 6 C 2 D 2 )各个资源都大于,P1进程需求资源数量为(A 0、 B 0、 C 1、 D 2 )(1、6、2、2)＞(0、0、1、2),安全,运行完P1进程后,剩余资源数量需要加上P1进程已分配资源数量,即: (1、6、2、2)＋(0、0、3、2)＝(1、6、5、4),接下来执行P4进程,此时已经运行完P1进程,所以此刻剩余资源数量为(1、6、5、4),(1、6、5、4)各项资源数量≥P4进程需求的资源数量(0、6、5、2),安全运行完P4进程后,剩余资源数量需要加上P4进程已分配资源数量,即:(1、6、5、4) ＋(0、3、3、2) ＝(1、9、8、6), 接下来执行P3进程,此时已经运行完P4进程,所以此刻剩余资源数量为(1、9、8、6)(1、9、8、6) )各项资源数量不能≥P3进程需求的资源数量(2、3、5、6),不安全因为,资源A此刻只有1个可用,而进程P3需要2个A资源.运行会发生死锁,然后就不需要运行其它进程了所以选项C:P1 P4 P3 P2 P5错误.同理选项D:P1 P3 P4 P5 P2和E:P1 P5 P4 P3 P2错误.。
2.银行家算法作业
P3
4 0 11
4 0 5
0 0 6
P4
4 2 5
4 0 5
0 2 0
P5
4 2 4
3 1 4
1 1 0
进行安全性检查
进程
work
need
allocation
Work+alloc
finish
P4
0 3 2
0 2 0
2 0 4
4 3 7
true
P5
4 3 7
1 1 0
3 1 4
7 4 11ቤተ መጻሕፍቲ ባይዱ
true
P3
7 4 11
0 0 6
4 0 5
11 4 16
true
P2
11 4 16
1 3 4
4 0 2
15 4 18
true
P1
15 4 18
3 4 7
2 1 2
17 5 20
true
由上表可知存在安全序列P4,P5,P3,P2,P1。因此系统是安全的，可以将P4所申请的资源进行分配。
2 2 1
2 0 4
4 3 7
true
P5
4 3 7
1 1 0
3 1 4
7 4 11
true
P3
7 4 11
0 0 6
4 0 5
11 4 16
true
P2
11 4 16
1 3 4
4 0 2
15 4 18
true
P1
15 4 18
3 4 7
2 1 2
17 5 20
true
T0时刻式安全的。
（2）P2: Request(0,3,4)< Need2(1,3,4)
银行家算法应用举例说明
银行家算法应用举例说明交通计算机翟高寿❑系统资源总量 Available[A,B,C] = {10, 5, 7} ❑T 0时刻 Available[A,B,C] = ❑安全分配序列 ?进程 MAX A B C Allocation A B C NeedA B CWorkA B CAllocation+ WorkA B CFinishP 0 7 5 3 0 1 0 P 1 3 2 2 2 0 0 P 2 9 0 2 3 0 2 P 3 2 2 2 2 1 1 P 4 4 3 30 0 27 4 3 1 2 26 0 0 0 1 1 4 3 1{3, 3, 2}❑系统资源总量 Available[A,B,C] = {10, 5, 7} ❑T 0时刻 Available[A,B,C] = {3, 3, 2} ❑安全分配序列 ?进程 MAX A B C Allocation A B C NeedA B C WorkA B CAllocation+ WorkA B CFinishP 0 7 5 3 0 1 0 7 4 3 P 1 3 2 2 2 0 0 1 2 2 3 3 25 3 2①TrueP 2 9 0 2 3 0 2 6 0 0 P 3 2 2 2 2 1 1 0 1 1 P 4 4 3 30 0 24 3 1❑系统资源总量 Available[A,B,C] = {10, 5, 7} ❑T 0时刻 Available[A,B,C] = {3, 3, 2} ❑安全分配序列 ?进程 MAX A B C Allocation A B C NeedA B C WorkA B CAllocation+ WorkA B CFinishP 0 7 5 3 0 1 0 7 4 3 P 1 3 2 2 2 0 0 1 2 2 3 3 25 3 2①TrueP 2 9 0 2 3 0 2 6 0 0 P 3 2 2 2 2 1 1 0 1 1 5 3 27 4 3②TrueP 4 4 3 30 0 24 3 1银行家算法应用举例之一D (待续)❑系统资源总量 Available[A,B,C] = {10, 5, 7} ❑T 0时刻 Available[A,B,C] = {3, 3, 2} ❑安全分配序列 ?进程 MAX A B C Allocation A B C NeedA B C WorkA B CAllocation+ WorkA B CFinishP 0 7 5 3 0 1 0 7 4 3 P 1 3 2 2 2 0 0 1 2 2 3 3 2 5 3 2 ①TrueP 2 9 0 2 3 0 2 6 0 0 P 32 2 22 1 10 1 15 3 2 7 4 3 ②TrueP 4 4 3 3 0 0 2 4 3 1 7 4 3 7 4 5 ③True银行家算法应用举例之一E (待续)❑系统资源总量 Available[A,B,C] = {10, 5, 7} ❑T 0时刻 Available[A,B,C] = {3, 3, 2} ❑安全分配序列 ?进程 MAX A B C Allocation A B C NeedA B C WorkA B CAllocation+ WorkA B C Finish P 0 7 5 3 0 1 0 7 4 3 7 4 5 7 5 5 ④True P 1 3 2 2 2 0 0 1 2 2 3 3 25 3 2①TrueP 2 9 0 2 3 0 2 6 0 0 P 3 2 2 2 2 1 1 0 1 1 5 3 2 7 4 3 ②True P 4 4 3 30 0 24 3 17 4 37 4 5③True银行家算法应用举例之一F (待续)❑系统资源总量 Available[A,B,C] = {10, 5, 7} ❑T 0时刻 Available[A,B,C] = {3, 3, 2} ❑安全分配序列< P 1 ,P 3 , P 4 , P 0 , P 2 >进程 MAX A B C Allocation A B C NeedA B C WorkA B CAllocation+ WorkA B C Finish P 0 7 5 3 0 1 0 7 4 3 7 4 5 7 5 5 ④True P 1 3 2 2 2 0 0 1 2 2 3 3 2 5 3 2 ①True P 2 9 0 2 3 0 2 6 0 0 7 5 5 10 5 7 ⑤True P 32 2 22 1 10 1 15 3 27 4 3②TrueP 4 4 3 3 0 0 2 4 3 1 7 4 3 7 4 5 ③True❑T 1时刻 Available[A,B,C] = {3, 3, 2}=>{2, 3, 0}❑进程P 1发出资源请求Request 1(1,0,2)< Need 1(1,2,2)❑安全分配序列 ?进程 MAX A B C Allocation A B C NeedA B C WorkA B CAllocation+ WorkA B CFinishP 0 7 5 3 0 1 0 7 4 3P 1 3 2 2 2 0 0 1 2 2 P 2 9 0 2 3 0 2 6 0 0 P 3 2 2 2 2 1 1 0 1 1 P 4 4 3 30 0 24 3 13 0 2 0 2 0❑进程P 1发出资源请求Request 1(1,0,2)< Need 1(1,2,2) ❑T 1时刻 Available[A,B,C] = {3, 3, 2}=>{2, 3, 0} ❑安全分配序列 ?进程 MAX A B C Allocation A B C NeedA B C WorkA B CAllocation+ WorkA B CFinishP 0 7 5 3 0 1 0 7 4 3 P 1 3 2 2 3 0 2 0 2 0 2 3 05 3 2①TrueP 2 9 0 2 3 0 2 6 0 0 P 3 2 2 2 2 1 1 0 1 1 P 4 4 3 30 0 24 3 1❑进程P 1发出资源请求Request 1(1,0,2)< Need 1(1,2,2) ❑T 1时刻 Available[A,B,C] = {3, 3, 2}=>{2, 3, 0} ❑安全分配序列 ?进程 MAX A B C Allocation A B C Need A B C WorkA B CAllocation+ WorkA B CFinishP 0 7 5 3 0 1 0 7 4 3 P 1 3 2 2 3 0 2 0 2 0 2 3 05 3 2①TrueP 2 9 0 2 3 0 2 6 0 0 P 3 2 2 2 2 1 1 0 1 1 5 3 27 4 3②TrueP 4 4 3 30 0 24 3 1❑进程P 1发出资源请求Request 1(1,0,2)< Need 1(1,2,2) ❑T 1时刻 Available[A,B,C] = {3, 3, 2}=>{2, 3, 0} ❑安全分配序列 ?进程 MAX A B C Allocation A B C Need A B C WorkA B CAllocation+ WorkA B CFinishP 0 7 5 3 0 1 0 7 4 3 P 1 3 2 2 3 0 2 0 2 0 2 3 05 3 2①TrueP 2 9 0 2 3 0 2 6 0 0 P 3 2 2 2 2 1 1 0 1 1 5 3 2 7 4 3 ②True P 4 4 3 30 0 24 3 17 4 37 4 5③True❑进程P 1发出资源请求Request 1(1,0,2)< Need 1(1,2,2) ❑T 1时刻 Available[A,B,C] = {3, 3, 2}=>{2, 3, 0} ❑安全分配序列 ?进程 MAX A B C Allocation A B C Need A B C WorkA B CAllocation+ WorkA B C Finish P 07 5 30 1 07 4 37 4 57 5 5④TrueP 1 3 2 2 3 0 2 0 2 0 2 3 0 5 3 2 ①TrueP 29 0 23 0 26 0 0P 3 2 2 2 2 1 1 0 1 1 5 3 2 7 4 3 ②True P 4 4 3 30 0 24 3 17 4 37 4 5③True银行家算法应用举例之二F (待续)❑进程P 1发出资源请求Request 1(1,0,2)< Need 1(1,2,2) ❑T 1时刻 Available[A,B,C] = {3, 3, 2}=>{2, 3, 0} ❑安全分配序列< P 1 ,P 3 , P 4 , P 0 , P 2 >进程MAX A B C AllocationA B CNeedA B CWorkA B CAllocation+ WorkA B CFinishP 0 7 5 3 0 1 0 7 4 3 7 4 5 7 5 5 ④True P 1 3 2 2 3 0 2 0 2 0 2 3 0 5 3 2 ①True P 2 9 0 2 3 0 2 6 0 0 7 5 5 10 5 7 ⑤True P 3 2 2 2 2 1 1 0 1 1 5 3 2 7 4 3 ②True P 44 3 30 0 24 3 17 4 37 4 5③True银行家算法应用举例之三(待续)❑T 2时刻 Available[A,B,C] = {2, 3, 0}❑进程P 4发出资源请求Request 4(3,3,0)< Need 4(4,3,1) ❑Request 4(3,3,0)> Available (2,3,0)，故让P 4等待进程 MAX A B C Allocation A B C NeedA B C WorkA B CAllocation+ WorkA B CFinishP 0 7 5 3 0 1 0 7 4 3 P 1 3 2 2 3 0 2 0 2 0 P 2 9 0 2 3 0 2 6 0 0 P 32 2 22 1 10 1 1P 4 4 3 3 0 0 2 4 3 1银行家算法应用举例之四(续完)❑T 3时刻 Available[A,B,C] = {2, 3, 0} =>{2, 1, 0} ❑进程P 0发出资源请求Request 0(0,2,0)< Need 0(7,4,3)❑尝试分配，则系统进入不安全状态，故而恢复状态进程 MAX A B C Allocation A B C Need A B C WorkA B CAllocation+ WorkA B CFinishP 0 7 5 3 0 1 0 7 4 3 P 1 3 2 2 3 0 2 0 2 0 P 2 9 0 2 3 0 2 6 0 0 P 3 2 2 2 2 1 1 0 1 1 P 44 3 30 0 24 3 10 3 0 7 2 3知行合一，开拓进取！银行家算法应用举例说明■。
《银行家算法》Word文档
设当前的系统状态如下表所示，系统此时Available=(1,1,2)。
问题：(1)(2) 此时系统是否处于安全状态，为什么？如果安全，则请给出一个安全序列；(3) 当P2发出资源请求向量request2(1,0,1)，此时系统能否把资源分配给它？为什么？如果能分配给它，则请给出一个安全序列；(4) 若在P2发出资源请求向量request2(1,0,1)后，若P1发出资源请求向量request1(1,0,1)，此时系统能否把资源分配给它？为什么？(5) 若在P1发出资源请求向量request1(1,0,1)后，若P3发出资源请求向量request3(0,0,1)，此时系统能否把资源分配给它？为什么？解答：(1) 各个进程还需要的资源数Cki-Aki(2) P3，P4。
(3) 当P2发出资源请求向量request2(1,0,1)，此时系统可以把资源分配给它，因为系统是安全的，相应的安全序列为：P2，P1，P3，P4。
(4) 若在P2发出资源请求向量request2(1,0,1)后，若P1发出资源请求向量request1(1,0,1)，此时系统不能把资源分配给它，因为此时系统资源不足。
(5) 若在P1发出资源请求向量request1(1,0,1)后，若P3发出资源请求向量request3(0,0,1)，此时系统不能把资源分配给它，因为如果分配，系统不安全，会导致死锁。
设系统中A、B、C、D共4种资源，在某时刻进程P0、P1、P2、P3、P4对资源的占有和需求情况如下表所示。
问题：(1) 计算各个进程还需要的资源数Cki-Aki；(2) 此时系统是否处于安全状态，为什么？如果安全，则请给出一个安全序列；(3) 若在P0发出资源请求向量request0(0,0,1,1)后，此时系统把资源分配给它是否安全？如果安全，则请给出一个安全序列；(4) 当P2发出资源请求向量request2(1,2,2,2)，此时系统能否把资源分配给它？为什么？(5) 若在P0发出资源请求向量request0(0,0,1,1)后，P4若发出资源请求向量request4(0,6,2,2)，此时系统能否把资源分配给它？为什么？(1) 各个进程还需要的资源数Cki-Aki(2) P1，P2。
银行家算法
某系统有A，B，C，D这4类资源供5个进程共享，进程对资源的需求和分配情况如下表所示。
现在系统还剩资源A类1个，B类5个，C类2个和D类0个，请按银行家算法回答下面问题：进程已占资源数最大需求数A B C D A B C DP1 0 0 1 2 0 0 1 2P2 1 0 0 0 1 7 5 0P3 1 3 5 4 2 3 5 6P4 0 6 3 2 0 6 5 2P5 0 0 1 4 0 6 5 6a.现在系统是否处于安全状态？b.如果现在进程P2提出需要（0，4，2，0）个资源的要求，系统能否满足它的请求？多谢！我被绕晕了，还有7天考试，救命啊！！！a.现在系统是否处于安全状态？是安全的。
进程_已占资源数_最大需求数_还需要的资源数_____A_B_C_D____A_B_C_D___A_B_C_DP1___0_0_1_2____0_0_1_2___0_0_0_0P2___1_0_0_0____1_7_5_0___0_7_5_0P3___1_3_5_4____2_3_5_6___1_0_0_2P4___0_6_3_2____0_6_5_2___0_0_2_0P5___0_0_1_4____0_6_5_6___0_6_4_2现在剩余的ABCD资源分别为1，5，2，0此时进程P1已经得到了所需要的资源，完成P1操作，把所占用的资源回收，所剩余的资源为1，5，3，2。
看P3,需要的资源数为1，0，0，2。
剩余的资源需求，分配给P3,P3完成操作，释放占有的资源，所以剩余资源变成2，8，8，6。
看P4,需要的资源数为0，0，2，0。
剩余的资源需求，分配给P4,P4完成操作，释放占有的资源，所以剩余资源变成2，14，11，8。
....................依次类推。
b.如果现在进程P2提出需要（0，4，2，0）个资源的要求，系统能否满足它的请求？安全。
进程P2提出需要（0，4，2，0）个资源的要求，进程_已占资源数_最大需求数_还需要的资源数_____A_B_C_D____A_B_C_D___A_B_C_DP1___0_0_1_2____0_0_1_2___0_0_0_0P2___1_4_2_0____1_7_5_0___0_7_5_0P3___1_3_5_4____2_3_5_6___1_0_0_2P4___0_6_3_2____0_6_5_2___0_0_2_0P5___0_0_1_4____0_6_5_6___0_6_4_2剩余资源ABCD为1，1，0，0。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
银行家算法例题
假定系统中有五个进程{P0，P1，P2，P3，P4} 和三类资源{A ，B,C},各种资源的数量分别为10、5、7，在T0 时刻的资源分配情况
（1）T0时刻的安全性
利用安全性算法对T0时刻的资源分配情况进行分析
（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向量，由此形成的资源变化情况如下图所示。
资源情况
进程
Max Allocation Need Available A B C A B C A B C A B C P0 7 5 3 0 1 0 7 4 3 3 3 2 P1 3 2 2 2 0 0 1 2 2 P2 9 0 2 3 0 2 6 0 0 P3 2 2 2 2 1 1 0 1 1 P4
4 3 3
0 0 2
4 3 1
资源情况 进程
Work A B C Need A B C Allocation A B C
Work+Allocati on A B C Finish
P1 3 3 2 1 2 2 2 0 0 5 3 2 TRUE P3 5 3 2 0 1 1 2 1 1 7 4 3 TRUE P4 7 4 3 4 3 1 0 0 2 7 4 5
TRUE P2 7 4 5 6 0 0 3 0 2 10 4 7 TRUE P0
10 4 7
7 4 3
0 1 0
10 5 7
TRUE
④再利用安全性算法检查此时系统是否安全。
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发出请求向量Requst0(0,2,0），系统按银行家算法进行检查：
资源情况
Max Allocatio Need Availabl A B C A B C A B C A B C P0 7 5 3 0 1 0 7 4 3 2 3 0 P1 3 2 2 3 0 2 0 2 0 P2 9 0 2 3 0 2 1 2 2 P3 2 2 2 2 1 1 0 1 1 P4
4 3 3
0 0 2
4 3 1
资源情况 进程 Work A B C
Need A B C Allocation A B C
Work+
Allocation A B C Finish P1 2 3 0 0 2 0 3 0 2 5 3 2 TRUE P3 5 3 2 0 1 1 2 1 1 7 4 3 TRUE P4 7 4 3 4 3 1 0 0 2 7 4 5 TRUE P0 7 4 5 7 4 3 0 1 0 7 5 5 TRUE P2
10 5 5
6 0 0
3 0 2
10 5 7
TRUE
①Request0（0, 2,0）≤Need0（7，4，3）； ②Request0（0,2,0）≤Available （2，3，0）；
③系统暂时先假定可为P0分配资源，并修改有关数据。
为P0分配资源后的有关资源数据
④进行安全性检查：可用资源Available （2，1，0）已不能满足任何进程的需要，故系统进入不安全状态，此时系统不分配资源。
Begin
Empty1=1; empty2=1; Full1=0; full2=0; Cobegin Input: Begin
Repeat
Wait(empty1);
将数据输入到缓冲区1中； Signal(full1); Until false End; Copy:
Begin
Repeat
Wait(full1);
从缓冲区1中提取数据； Signal(empty1);
资源情况 进程
Allocatio Need Availabl A B C A B C A B C P0 0 1 0 7 2 3 2 1 0 P1 3 0 2 0 2 0 P2 3 0 2 6 0 0 P3 2 1 1 0 1 1 P4
0 0 2
4 3 1
Wait(empty2);
将数据复制到缓冲区2；
Signal(full2);
Until false
End;
Output:
Begin
Repeat
Wait(full2);
将数据从缓冲区2中取出打印；
Signal(empty2);
Until false
End;
Coend
End;。