银行家算法安全序列怎么找
① 银行家算法的安全序列怎么寻找
1）安全。
安全序列 P1 P3 P4 P0 P2
（从第一个进程开始，找所需资源数小于系统可用资源数的进程(P1 Need(1 2 2) < Availabe(3 3 2)),该进程需求满足后把其所有资源还给系统(Available(5 3 2)，依此。）
2)不能.
如果满足P1的请求Request（1，0，2）后，P1的需求没有完全满足，也就是说P1获得该资源后不会结束，依然在等待系统分配资源。
而系统剩余资源为(2,3,0)不能再满足任何进程的需求,处在不安全状态，可能产生死锁。
② 银行家算法(操作系统）
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），可以直接满足。
③ 银行家算法得出的安全序列有顺序吗如{ p3，p0，p4 ，p2， p1}和{ p3，p0，p4 ，p1， p2}是一样的吗
不一样
银行家算法假定前提如下：
p0 ~ p 4 各掌握有银行家的若干资源，但要求完成他们的目标，分别还需要请求若干资源。
现在，银行家已经付出很多资源，手里资源不多。而pX 们另外需求的资源也是大小不一的。
而一旦银行家所有资源支出后，pX中仍然没有谁完成任务，这就死锁了（每个进程都把握一部分资源，并还在要资源，而资源已经木有了）
==========================
现在，算法得出这样一条顺序，先优先供应p3,等p3完成他的线程后，p3会释放所占有的资源。银行家（系统）利用p3所有的资源和自己手里剩余的资源按顺序供应p0，p4 等等。
现在假定 供应完 p4后，银行家手中握有资源 10单位
p1 总共需要20单位才能完成他的进程，而p1手中现有5单元
p2 总共需要10单位才能完成他的进程，而p2手中已经有了8单元了
请问，系统应该先供应哪个线程？
答案必然是先p2再p1
因为使用2资源供应完p2（10单位才能完成，已有8单位，还要2单位）,p2完成任务后，释放所有资源，系统累计资源才有 10 - 2 + 10 = 18 单位的资源 ，才能满足p1 的 15( = 20 -5 ）单位资源的请求。
而若反之， 所有资源投入p1 , p1 完成进度 15 / 20 p2 完成进度 8 / 10 这就彻底死了
所以 xxxxx p2 p1 能活， xxxxx p1 p2 会死
特别说明的是，银行家算法可以得到不止一条安全顺序。能被银行家证明可行的算法都是死不了的算法
④ 银行家算法的多个安全序列的输出
银行家算法=-- -
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(在推算过程中,所有进程均可以完成),则表示(分配过后)系统是安全的,否则系统是不安全的.
⑤ “银行家算法”是怎样的一个算法
银行家算法=-- -
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
⑥ 银行算法怎么求出全部安全序列
先说一下银行家的算法：
设进程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)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。
=================================================
题目中的计算过程：
先算出每个进程还需要多少进程才能满足，即Request的值
=
Need
-
Allocation
进程名
Allocation
Need
Request
Available
ABC
ABC
ABC
ABC
P1
4
0
5
4
0
11
0
0
6
2
3
3
P2
4
0
2
5
3
6
1
2
4
P3
2
1
4
4
2
5
2
1
1
P4
2
1
2
5
5
9
3
4
7
P5
3
1
3
4
2
4
1
1
1
第一题A项p3
p1
p4
p2
p5
先分配给P3，其Request(2,1,1)
<
available(2,2,3)
满足，分配资源等待P3完成，P3进程完成之后，Available
=
(2,1,4)
+
(2,3,3)
=
(4,4,7)
然后分配给p1,其Request(0,0,6)
<
available(4,4,7)，可以满足资源，分配资源给P1,P1完成任务释放资源Available
=
(4,0,5)
+(4,4,7)
=
(8,4,12)
接着P4，request(3
4
7)
<
available(8,4,12),可以满足资源，分配资源给P4,P4完成任务释放资源Available
=
(2,1,2)
+(8,4,12)
=
(10,5,14)
接着p2，request(1
2
4)
<
available(10,5,14)可以满足资源，分配资源给P4,P4完成任务释放资源Available
=
(4,0,2)+
(10,5,14)
=
(14,5,16)
最后P5,request(1
1
1)
<
available(14,5,16)可以满足资源，分配资源给P4,P4完成任务,资源全部释放，变为(3
1
3
)+
(14,5,16)
=
(17,6,19)
所以A是安全序列。
同理分析B
p1
p3
p5
p2
p4，先分配给P1的话Request(0,0,6)
>
available(2,3,3)，C资源不满足，所以该序列不安全。
分析C项p4
p2
p3
p5
p1,先分配给p4,
Request(3,4,7)
>
available(2,3,3)，ABC资源都不满足，该序列不安全。
分析D项p2
p3
p1
p4
p5，先分配给P2，Request(1,2,4)
>
available(2,3,3)，C资源不满足，所以该序列不安全。
第二题，分析方法跟上面的一样，只是比较费时。如果单选的话，看一下答案，D项，先分配给P4，显然完成P4还需(
3
4
7)
,其大于
available，所D项不安全。
⑦ 求n个数的全排列，n不定。用c语言。用于银行家算法中求安全序列
好久没用c了，所以代码可能要用到伪代码
先定义a[maxn]
用子函数递归
void p(int x)
{
if (n == x+1)
{
//foreach a print
//输出数组a
}
for (int i=1 to n)
{
a[x] = i;
p(x+1);
a[x] = 0;
}
}
主函数main调用p(n)
⑧ 银行家算法安全序列怎么判断
先说一下银行家的算法：
设进程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)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。
=================================================
题目中的计算过程：
先算出每个进程还需要多少进程才能满足，即Request的值 = Need - Allocation
进程名 Allocation Need Request Available
ABC ABC ABC ABC
P1 4 0 5 4 0 11 0 0 6 2 3 3
P2 4 0 2 5 3 6 1 2 4
P3 2 1 4 4 2 5 2 1 1
P4 2 1 2 5 5 9 3 4 7
P5 3 1 3 4 2 4 1 1 1
第一题A项p3 p1 p4 p2 p5
先分配给P3，其Request(2,1,1) < available(2,2,3) 满足，分配资源等待P3完成，P3进程完成之后，Available = (2,1,4) + (2,3,3) = (4,4,7)
然后分配给p1,其Request(0,0,6) < available(4,4,7)，可以满足资源，分配资源给P1,P1完成任务释放资源Available = (4,0,5) +(4,4,7) = (8,4,12)
接着P4，request(3 4 7) < available(8,4,12),可以满足资源，分配资源给P4,P4完成任务释放资源Available = (2,1,2) +(8,4,12) = (10,5,14)
接着p2，request(1 2 4) < available(10,5,14)可以满足资源，分配资源给P4,P4完成任务释放资源Available = (4,0,2)+ (10,5,14) = (14,5,16)
最后P5,request(1 1 1) < available(14,5,16)可以满足资源，分配资源给P4,P4完成任务,资源全部释放，变为(3 1 3 )+ (14,5,16) = (17,6,19)
所以A是安全序列。
同理分析B p1 p3 p5 p2 p4，先分配给P1的话Request(0,0,6) > available(2,3,3)，C资源不满足，所以该序列不安全。
分析C项p4 p2 p3 p5 p1,先分配给p4, Request(3,4,7) > available(2,3,3)，ABC资源都不满足，该序列不安全。
分析D项p2 p3 p1 p4 p5，先分配给P2，Request(1,2,4) > available(2,3,3)，C资源不满足，所以该序列不安全。
第二题，分析方法跟上面的一样，只是比较费时。如果单选的话，看一下答案，D项，先分配给P4，显然完成P4还需( 3 4 7) ,其大于 available，所D项不安全。
⑨ 银行家算法没有给出avaible怎样求安全序列
楼上已经说的比较详细了，再提一点安全系列是不唯一的，也就是说可能有很多种，你只要找到一种即可
⑩ （C++）银行家算法安全序列有多个,我怎么确定我找的安全序列是哪种方式。就比如说
一种是深度优先搜索，一种是广度优先搜索，都行啊