银行家算法例题
计算机操作系统之银行家算法
淮海工学院计算机工程学院实验报告书课程名：《计算机操作系统》题目：实验二银行家算法班级： ^ ^ 姓名： ^ ^实验二银行家算法实验目的和要求应用银行家算法验证进程安全性检查及分配资源编制模拟银行家算法的程序，并以以下例子验证程序的正确性。
实验环境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、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 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;。