银行家算法例题
计算机操作系统之银行家算法
淮海工学院计算机工程学院实验报告书课程名：《计算机操作系统》题目：实验二银行家算法班级： ^ ^ 姓名： ^ ^实验二银行家算法实验目的和要求应用银行家算法验证进程安全性检查及分配资源编制模拟银行家算法的程序，并以以下例子验证程序的正确性。
实验环境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。
银行家算法问题
银行家算法问题1、银行家算法中的数据结构（1）可利用资源向量Available ： []Availabel j k = 式中：j 01j m ≤≤-一个含有m 个（类）元素的数组，每个元素代表一类可利用的资源数目。
上式表示系统中现有的第j 类资源可用数目为k 个。
（2）最大需求矩阵Max ： [,]Max i j k = 式中： i 01i n ≤≤-j 01j m ≤≤-n 个进程中的每一个进程对m 类资源的最大需求量，上式表示进程i 需求第j 类资源的最大数目为k 。
（3）分配矩阵Allocation ： [,]Allocation i j k = 式中： i 01i n ≤≤- j 01j m ≤≤-n 个进程中的每一个进程对m 类资源的分配量，上式表示进程i 已分配到第j 类资源的数目为k 。
（4）需求矩阵Need ：[,]Need i j k = 式中： i 01i n ≤≤- j 01j m ≤≤-n 个进程中的每一个进程对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 =- [,][,]R e [i A l l o c a t i o n i jA l l o c a t i o n i j q u e s t j=+ [,][,]Re []i Need i j Need i j quest j =-（4）系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。
银行家算法解题方法
5 3 5 4
5 true 2 true 7 true
2
7
3
5
0
5
5
7
3
4
2
3
0
4
1
3
1
1
3 true
0
0
2
7
4
5 true
因为先分配资源给P1进程符合按安全序列{P1、P3 、P4、P0、P2}分配资源，所以试探将资源分配给进 程P1后的状态是安全的，可将资源分配给进程P1。
4．银行家算法之例
③ T1之后的T2时刻P4请求资源 Request4(3,3,0)是否允许？
如果在银行家算法中，把P0发出的请求向 量改为Request0(0，1，0)，系统是否能将 资源分配给它，请读者考虑。
工作向量Work.它表示系统可提供给进程继续运行所需要的各类资源的 数目
资源情况 进程 A work B Need B Allocation A B C
Work＋Allocation finish
C
ACA源自BCP0 P1 P2 P3 P4
7 3 7 5
4 3 5 3
5 2 5 2
7 1 6 0 4
4 2 0 1 3
Request0(0，2，0)≤Need0(7，4，3)； Request0(0，2，0)≤Available(2，3，0)； 系统暂时先假定可为P0分配资源，并修改有关数据， 如下图所示。
4．银行家算法之例
进行安全性检查：可用资源Available(2，1，0) 已不能满足任何进程的需要，故系统进入不安 全状态，此时系统不分配资源。
• Available(2,3,0) = Available(3,3,2)Request1(1,0,2); • Need1(0,2,0) = Need1(1,2,2)-Request1(1,0,2); • Allocation1(3,0,2) =Allocation1(2,0,0)+Request1(1,0,2);
（完整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。
银行家算法
假设系统中有三类互斥资源R1、R2和R3，可用资源数分别为9、8、5.在T0时刻系统中有P1、P2、P3、P4和P5五个进程，这些进程对资源的最大需求量和已分配资源数如下表所示。
如果进程按照(___) 序列执行，那么系统状态是安全的。
A：P1 -> P2 -> P4 -> P5 -> P3B：P2 -> P1 -> P4 -> P5 -> P3C：P2 -> P4 -> P5 -> P1 -> P3D：P4 -> P2 -> P4 -> P1 -> P3答案：C下面我们就对这道题进行详细的解析，在考试中如果出现这样的题都是一个解题思路。
首先，我们根据上述图形绘制出每个进程中R1、R2、R3中剩余的资源数。
我用下面的表格图进行显示。
根据题意，我们知道现在 R1对应资源是9，R2对应资源是8，R3对应资源是5。
P1、P2、P3、P4、P5总用使用的资源是：7 7 5.剩余资源数是：2 1 0根据我们绘制的图表中发现，P1-P5中只有P2的剩余资源小于总的剩余资源数，所以选择P2。
根据4个选项，我们首先排除了A、D选项。
P2运行完成之后，会释放所占用的资源，此时总得剩余资源数是：4 2 1。
如何得到 4 2 1 这个数呢？总得剩余资源 + P2释放的资源数。
P2运行完成之后，需要从P1、P3、P4、P5中进行匹配。
根据剩余资源量我们可以看出，只有P4符合条件。
再看剩余的选项，此时，可以直接筛选出C选项符合。
如果是简单题，可以继续按照上述步骤进行操作，运行完一个进程，需要释放当前进程占用的资源，供下一个进程使用。
银行家算法
某系统有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。
银行家算法习题
假设一家银行拥有资金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、实验题目哲学家就餐问题是一种典型的同步问题，它是由Dijkstra 提出并解决的。
该问题描述如下：有五个哲学家，他们的生活方式是交替的进行思考和进餐。
哲学家们共用一张圆桌，如图所示：设五个哲学家分别编号为A，B，C，D，E，桌子上放着五把筷子，筷子分别编号为0，1，2，3，4，桌子中央有一盘饭菜。
五个哲学家都很有礼貌，都要等同时拿到身旁的两只筷子才进餐，不然就只是等着继续思考，而且吃了一口之后又马上放下拿起的两根筷子，继续思考。
由于筷子数目有限，不能让五个哲学家同时进餐，而且甚至只能让其中的少数哲学家进餐，其他的哲学家只能轮流享用，这非常类似多线程之间的同步互斥问题，所以采用windows 的多线程及一些API函数实现了对这个经典算法的模拟。
2、实验要求设计有n个进程共享m个系统资源的系统，进程可动态的申请和释放资源，系统按各进程的申请动态的分配资源。
系统能显示各个进程申请和释放资源，以及系统动态分配资源的过程，便于用户观察和分析；实验二：进程调度1 设计目的（1）要求学生设计并实现模拟进程调度的算法：时间片轮转及先来先服务。
（2）理解进程控制块的结构。
（3）理解进程运行的并发性。
（4）掌握进程调度算法。
2 设计要求在多道程序运行环境下，进程数目一般多于处理机数目，使得进程要通过竞争来使用处理机。
这就要求系统能按某种算法，动态地把处理机分配给就绪队列中的一个进程，使之运行，分配处理机的任务是由进程调度程序完成的。
一个进程被创建后，系统为了便于对进程进行管理，将系统中的所有进程按其状态，将其组织成不同的进程队列。
于是系统中有运行进程队列、就绪队列和各种事件的进程等待队列。
进程调度的功能就是从就绪队列中挑选一个进程到处理机上运行。
进程调度的算法有多种，常用的有优先级调度算法、先来先服务算法、时间片轮转算法。
进程是程序在处理机上的执行过程。
进程存在的标识是进程控制块（PCB），进程控制块结构如下：typedef struct node{char name[10]; /* 进程标识符 */int prio; /* 进程优先数 */int round; /* 进程时间轮转时间片 */int cputime; /* 进程占用 CPU 时间*/int needtime; /* 进程到完成还需要的时间*/int count; /* 计数器*/char state; /* 进程的状态*/struct node *next /*链指针*/}PCB;系统创建一个进程，就是由系统为某个程序设置一个PCB，用于对该进程进行控制和管理，进程任务完成，由系统收回其PCB，该进程便消亡。
银行家算法案例
银行家算法案例银行家算法是一种资源分配方法，最早由美国银行家在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错误.。
软件综合实训 银行家算法
系统中的所有进程放入进程集合，在安全状态
下系统受到进程的请求后试探性的给其分配资 源，然后将剩下的资源和进程集合与其他进程 还需要的资源数做比较，找出剩余资源能满足 最大需求量的进程，从而保证进程运行完成后 还回全部资源。这时系统将该进程从进程集合 中清除。此时系统中的资源就更多了。反复执 行上面的步骤，最后检查到进程的集合为空时 就表明本次申请可行，系统处于安全状态，可 以实施本次分配，否则，只要进程集合非空， 系统便处于不安全状态，本次不能分配给它。 请进程等待。
第五组
ห้องสมุดไป่ตู้过随机函数产生系统的资源数以及T0时
刻进程对资源的占用及需求情况的表项，以 及T0时刻系统的可利用资源数。
1）如果Request<=Need,则转向步骤(2)；否则， 认为出错，因为它所需要的资源数已超过它所宣布 的最大值。 （2）如果Request<=Available,则转向步骤（3）； 否则，表示系统中尚无足够的资源，进程必须等待。 （3）系统试探把要求的资源分配给进程Pi,并修改 下面数据结构中的数值： Available=Available-Request; Allocation=Allocation+Request; Need=Need-Request; (4)系统执行安全性算法，检查此次资源分配后，系 统是否处于安全状态。
（2）从进程集合中找到一个能满足下述条
件的进程： ①Finish[i]=false ②Need<or=Work 如找到，执行步骤（3）；否则，执行步骤 （4）。
（3）当进程P获得资源后，可顺利执行，
直至完成，并释放出分配给它的资源，故应 执行： Work=Work+Allocation; Finish[i]=true; 转向步骤（2）。 （4）如果所有进程的Finish[i]=true,则表 示系统处于安全状态；否则，系统处于不安 全状态。
《银行家算法》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。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
银行家算法例题（P120）
例：系统中原有三类资源A、B、C和五个进程P1、P2、P3、P4、P5，A资源17，B资源5，C资源20。
T0时刻系统资源分配和进程最大需求如下表。
1、T0时刻系统是否处于安全状态？
2、是否可以允许以下请求？
(1) T1时刻：P2 Request2=(0,3,4)
(2 ) T2时刻：P4 Request4=(2,0,1)
(3)T3时刻：P1 Request1=(0,2,0)
注：T0 T1 T2 T3时刻是前后顺序，后一时刻是建立在前一时刻的基础上。
解：由题可知Need=Max-Allocation
Available A=17-(2+4+4+2+3)=2(原有-分配)
同理Available B=3,Available C=3
即T0时刻资源分配表如下所示（表中数据顺序均为A B C）：
1、判断T0时刻是否安全，执行安全算法找安全序列，过程如下表：
T0时刻能找到一个安全序列{P4,P3,P2,P5,P1},故T0时刻系统处于安全状态。
2、判断T1 T2 T3时刻是否满足进程请求进行资源分配。
（1）T1时刻，P2 Request2=(0,3,4)
//第一步判断条件
①满足Request2=(0,3,4)<=Need2(1,3,4)
②不满足Request2=(0,3,4)<=Available(2,3,3)
故系统不能将资源分配给它，此时P2必须等待。
（2）T2时刻，P4 Request4=(2,0,1)
//第一步判断条件
①满足Request4=(2,0,1)<=Need4(2,2,1)
②满足Request4=(2,0,1)<=Available(2,3,3)
//第二步修改Need、Available、Allocation的值
Available=Available-Request4= (0,3,2)
Allocation4=Allocation4+Request4=(4,0,5)
Need4=Need4-Request4=(0,2,0)
//第三步执行安全算法，找安全序列
(注：先写上work，其初值是系统当前进行试分配后的Available(0,3,2)，找五个进程中Need小于work的进程，比如Need4<=Work满足，则将P4写在第一行的最前面，同时写出P4的Need和Allocation，以此类推)
//第四步在T2时刻存在安全序列{P4,P2,P3,P5,P1},则满足Request4请求，将Request4=(2,0,1)分配给P4。
（3）T3时刻，P1 Request1=(0,2,0)
//第一步判断条件
①满足Request1=(0,2,0)<=Need1(3,4,7)
②满足Request1=(0,2,0)<=Available(2,3,3)
//第二步修改Need、Available、Allocation的值
Available=Available-Request1= (0,1,2)(在T2时刻基础上)
Allocation=Allocation1+Request1=(2,3,2)
Need1=Need1-Request1=(3,2,7)
//第三步执行安全算法，找安全序列
对于所有Need i均不小于Work(初值是Available (0,1,2))，找不到安全序列，故系统不能将资源分配给它，P1必须等待。
归纳总结——银行家算法解题总结为四步走：
第一步：判断银行家算法中的条件，看是否满足，如果满足跳转第二步（判断条件）
①Request i<=Need i
②Request i<=Available
第二步：试图分配，修改Need、Available、Allocation的值（修改NAA）Available=Available-Request i
Allocation i=Allocation i+Request i
Need i=Need i-Request i
第三步：执行安全算法，找安全序列（找安全序列）
第四步：找到了安全序列，则此时系统满足进程P i的请求Request i。
（真分配）系统不会进入不安全状态，即可将Request i分配给进程P
i
银行家算法解题流程图：。