操作系统-银行家算法（五）

最新推荐文章于 2024-06-22 13:51:25 发布

WY_Matcha

最新推荐文章于 2024-06-22 13:51:25 发布

阅读量1.2k

点赞数 2

分类专栏：操作系统文章标签：操作系统银行家算法安全性算法

本文链接：https://blog.csdn.net/weixin_44098853/article/details/107164144

版权

操作系统专栏收录该内容

5 篇文章 2 订阅

订阅专栏

一、银行家算法

设 $Request_{i}$ 是进程 $P_{i}$ 的请求向量，如果 $Request_{i}$ [j]=K，表示进程 $P_{i}$ 需要K个 $R_{j}$ 类型的资源。当 $P_{i}$ 发出资源请求后，系统按下述步骤进行检查：

（1）如果 $Request_{i}$ [j]≤Need[i，j]，便转向步骤（2）；否则认为出错，因为它所需要的资源数已超过它所宣布的最大值。

（2）如果 $Request_{i}$ [j]≤Available[j]，便转向步骤（3）；否则，表示尚无足够资源， $P_{i}$ 须等待。

（3）系统试探着把资源分配给进程 $P_{i}$ ，并修改下面数据结构中的数值：

Available[j] = Available[j] - $Request_{i}$ [j]；

Allocation[i，j] = Allocation[i，j] + $Request_{i}$ [j]；

Need[i，j] = Need[i，j] - $Request_{i}$ [j]；

（4）系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程 $P_{i}$ ，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程等待。

二、安全性算法

系统所执行的安全性算法可描述如下：

（1）设置两个向量：

①工作向量Work，它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全性算法开始时，Work = Available；

②Finish：它表示系统是否有足够的资源分配给进程，使之运行完成。开始时先做Finish[i] = false；当有足够资源分配给进程时，再令Finish[i] = true。

（2）从进程集合中找到一个能满足下述条件的进程：

①Finish[i] = false;

②Nee[i，j] ≤ Work[j]；

若找到，执行步骤（3），否则，执行步骤（4）。

（3）当进程 $P_{i}$ 获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：

Work[j] = Work[j] + Allocation[i，j]；

Finish[i] = true；

go to step 2；

（4）如果所有进程的Finish[i] = true都满足，则表示系统处于安全状态；否则，系统处于不安全状态。

三、银行家算法之例

假定系统中有五个进程{ $P_{0},P_{1},P_{2},P_{3},P_{4}$ }和三类资源{A,B,C}，各种资源的数量分别为10、5、7，在 $T_{0}$ 时刻的资源分配情况如图3-1所示。

图3-1 $T_{0}$ 时刻的资源分配表
	Max	Allocation	Need	Available
	A B C	A B C	A B C	A B C
$P_{0}$	7 5 3	0 1 0	7 4 3	3 2 2 (2 3 0)
$P_{1}$	3 2 2	2 0 0 (3 0 2)	1 2 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_{4}$	4 3 3	0 0 2	4 3 1

（1） $T_{0}$ 时刻的安全性：利用安全性算法对 $T_{0}$ 时刻的资源分配情况进行分析（如图3-2所示）可知，在 $T_{0}$ 时刻存在着一个安全序列{ $P_{1},P_{3},P_{4},P_{2},P_{0}$ }，故系统是安全的。

图3-2 $T_{0}$ 时刻的安全序列
	Work	Need	Allocation	Work+Allocation	Finish
	A B C	A B C	A B C	A B C	Finish
$P_{1}$	3 3 2	1 2 2	2 0 0	5 3 2	true
$P_{3}$	5 3 2	0 1 1	2 1 1	7 4 3	true
$P_{4}$	7 4 3	4 3 1	0 0 2	7 4 5	true
$P_{2}$	7 4 5	6 0 0	3 0 2	10 4 7	true
$P_{0}$	10 4 7	7 4 3	0 1 0	10 5 7	true

（2） $P_{1}$ 请求资源： $P_{1}$ 发出请求向量 $Request_{1}$ (1,0,2)，系统按银行家算法进行检查：

① $Request_{1}$ (1,0,2)≤ $Need_{1}$ (1,2,2);

② $Request_{1}$ (1,0,2)≤ Available(3,3,2);

③系统先假定可为 $P_{1}$ 分配资源，并修改Available， $Allocation_{1}$ 和 $Need_{1}$ 向量，由此形成的资源变化情况如图3-1中的圆括号所示；

④再利用安全性算法检查此时系统是否安全，如图3-3所示。

图3-3 P1申请资源时的安全性检查
	Work	Need	Allocation	Work+Allocation	Finish
	A B C	A B C	A B C	A B C	Finish
$P_{1}$	2 3 0	0 2 0	3 0 2	5 3 2	true
$P_{3}$	5 3 2	0 1 1	2 1 1	7 4 3	true
$P_{4}$	7 4 3	4 3 1	0 0 2	7 4 5	true
$P_{0}$	7 4 5	7 4 3	0 1 0	7 5 5	true
$P_{2}$	7 5 5	6 0 0	3 0 2	10 5 7	true

由此进行的安全性检查得知，可以找到一个安全序列{ $P_{1},P_{3},P_{4},P_{0},P_{2}$ }。因此，系统是安全的，可以立即将 $P_{1}$ 所申请的资源分配给它。

（3） $P_{4}$ 请求资源： $P_{4}$ 发出请求向量 $Request_{4}$ (3,3,0)，系统按银行家算法进行检查：

① $Request_{4}$ (3,3,0)≤ $Need_{4}$ (4,3,1);

② $Request_{4}$ (3,3,0)≤Available(2,3,0)，让 $P_{4}$ 等待。

（4） $P_{0}$ 请求资源： $P_{0}$ 发出请求向量 $Request_{0}$ (0,2,0)，系统按银行家算法进行检查：

① $Request_{0}$ (0,2,0)≤ $Need_{0}$ (7,4,3);

② $Request_{0}$ (0,2,0)≤Available(2,3,0);

③系统暂时先假定可为 $P_{0}$ 分配资源，并修改有关数据，如图3-4所示。

	Allocation	Need	Available
	A B C	A B C	A B C
$P_{0}$	0 3 0	7 2 3	2 1 0
$P_{1}$	3 0 2	0 2 0
$P_{2}$	3 0 2	6 0 0
$P_{3}$	2 1 1	0 1 1
$P_{4}$	0 0 2	4 3 1

（5）进行安全性检查：可用资源Available(2,1,0)已不能满足任何进程的需要，故系统进入不安全状态，此时系统不分配资源。

四、举例说明

解：（1）

资源分配表
	Max	Allocation	Need	Available
	R1 R2 R3 R4	R1 R2 R3 R4	R1 R2 R3 R4	R1 R2 R3 R4
$P_{0}$	0 0 1 2	0 0 1 2	0 0 0 0	1 5 0 2
$P_{1}$	1 7 5 0	1 0 0 0	0 7 5 0
$P_{2}$	2 3 5 6	1 3 5 4	1 0 0 2
$P_{3}$	0 6 5 2	0 6 3 2	0 0 2 0
$P_{4}$	0 6 5 6	0 0 1 4	0 6 4 2

（2）

	Work	Need	Allocation	Work+Allocation	Finish
	R1 R2 R3 R4	R1 R2 R3 R4	R1 R2 R3 R4	R1 R2 R3 R4	Finish
$P_{0}$	1 5 0 2	0 0 0 0	0 0 1 2	1 5 1 4	true
$P_{2}$	1 5 1 4	1 0 0 2	1 3 5 4	2 8 6 8	true
$P_{1}$	2 8 6 8	0 7 5 0	1 0 0 0	3 8 6 8	true
$P_{3}$	3 8 6 8	0 0 2 0	0 6 3 2	3 14 9 10	true
$P_{4}$	3 14 9 10	0 6 4 2	0 0 1 4	3 14 10 14	true

利用安全性算法对此时刻的资源分配情况进行分析（如上图）可知，此时刻存在着一个安全序列{ $P_{0},P_{2},P_{1},P_{3},P_{4}$ }，故此系统是安全的。

（3） $P_{4}$ 请求资源： $P_{4}$ 发出请求向量 $Request_{4}$ (0,2,0,2)，系统按银行家算法进行检查：

① $Request_{4}$ (0,2,0,2)≤ $Need_{4}$ (0,6,4,2)；

② $Request_{4}$ (0,2,0,2)≤Available(1,5,0,2)；

③系统先假定可为 $P_{4}$ 分配资源，并修改Available， $Allocation_{4}$ 和 $Need_{4}$ 向量；

④再利用安全性算法检查此时系统是否安全，如下图所示：

	Work	Need	Allocation	Work+Allocation	Finish
	R1 R2 R3 R4	R1 R2 R3 R4	R1 R2 R3 R4	R1 R2 R3 R4	Finish
$P_{0}$	1 3 0 0	0 0 0 0	0 0 1 2	1 3 1 2	true
$P_{2}$	1 3 1 2	1 0 0 2	1 3 5 4	2 6 6 6	true
$P_{3}$	2 6 6 6	0 0 2 0	0 6 3 2	2 12 9 8	true
$P_{1}$	2 12 9 8	0 7 5 0	1 0 0 0	3 12 9 8	true
$P_{4}$	3 12 9 8	0 4 4 0	0 2 1 6	3 14 10 14	true

由所进行的安全检查得知，可以找到一个安全序列{ $P_{0},P_{2},P_{3},P_{1},P_{4}$ }。因此，系统是安全的，可以立即将 $P_{4}$ 所申请的资源分配给它。

解：（1）

①P1申请3个，满足；系统还剩7个。（10-3=7）

②P2申请2个，满足，系统还剩5个。（7-2=5）

③P3申请4个，若满足它的请求，可能使以后的任何进程都不能运行完，因此P3等待。

④P1申请2个，满足；系统还剩3个。（5-2=3）

⑤P2申请2个，不能满足，等待。

此时系统的分配情况如下：

P1分配5个后正在运行，P2分配2个后等待分配2个，P3等待分配4个，系统还剩3个。

（2）

①P1接着运行，P1申请3个可满足。P1运行完成后，释放资源，使系统的资源数量变为8个。（5+3=8）

②首先将P3唤醒，满足它的4个资源，系统还剩4个，可以唤醒P2，满足它的2个请求，系统还剩2个。（8-4-2=2）

③P3申请3个，不能满足，等待。

④P2申请2个，系统满足它，P2接着运行，P2完成，释放资源，使系统资源变为6个。（2+4=6）

⑤系统唤醒P3，满足它的资源请求，最终P3完成，释放资源，使资源数量恢复为10个。

因此，找到的进程完成序列为P1，P2，P3。

WY_Matcha

关注

2
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
操作系统-银行家算法（五）

一、银行家算法设是进程的请求向量，如果[j]=K，表示进程需要K个类型的资源。当发出资源请求后，系统按下述步骤进行检查：（1）如果[j]≤Need[i，j]，便转向步骤（2）；否则认为出错，因为它所需要的资源数已超过它所宣布的最大值。（2）如果[j]≤Available[j]，便转向步骤（3）；否则，表示尚无足够资源，须等待。（3）系统试探着把资源分配给进程，并修改下面数据结构中的数值：Available[j] = Available[j] -[j]；Allocation[i，..
复制链接

扫一扫