银行家算法（Banker’s Algorithm）详解

haoshenwan

已于 2025-02-25 13:53:03 修改

阅读量1.8k

点赞数 26

分类专栏： Java基础文章标签：算法服务器 java

于 2025-02-25 13:36:28 首次发布

本文链接：https://blog.csdn.net/haoshenwan/article/details/145850808

版权

Java基础专栏收录该内容

4 篇文章

订阅专栏

银行家算法（Banker’s Algorithm）详解

银行家算法（Banker’s Algorithm）是操作系统领域用于 避免死锁 的经典算法，由 Edsger Dijkstra 于 1965 年提出。其核心思想是通过模拟资源分配过程，判断系统是否处于安全状态，从而决定是否满足进程的资源请求。该算法名称来源于银行家发放贷款时的风险控制逻辑：银行家在放贷前需确保留有足够资金应对所有客户的潜在需求，避免因资金链断裂而破产。

一、死锁与资源分配

在理解银行家算法前，需明确以下背景知识：

死锁的四个必要条件
- 互斥：资源不可共享。
- 占有并等待：进程持有资源并等待其他资源。
- 不可抢占：资源只能自愿释放。
- 循环等待：进程间形成环形等待链。
死锁处理方法
- 预防：破坏死锁的必要条件（如一次性分配所有资源）。
- 避免：动态检查资源分配的安全性（银行家算法）。
- 检测与恢复：允许死锁发生，定期检测并解除。

银行家算法属于 死锁避免 策略，需提前知道进程的 最大资源需求。

二、银行家算法的核心概念

1. 数据结构

假设系统有 ( n ) 个进程和 ( m ) 种资源：

Available（可用资源向量）：长度为 ( m )，表示每种资源的可用数量。
Max（最大需求矩阵）：( n \times m ) 矩阵，记录每个进程对每种资源的最大需求。
Allocation（分配矩阵）：( n \times m ) 矩阵，记录每个进程当前已分配的资源。
Need（需求矩阵）：( n \times m ) 矩阵，表示每个进程还需多少资源（( \text{Need}[i] = \text{Max}[i] - \text{Allocation}[i] )）。

2. 安全状态

系统处于 安全状态 的条件是：存在一个进程执行序列（安全序列），使得按此序列分配资源后，所有进程都能顺利完成。若不存在这样的序列，则系统处于 不安全状态，可能发生死锁。

三、算法步骤详解

1. 安全性检查算法

判断当前系统是否处于安全状态：

初始化 Work = Available，Finish 数组标记所有进程为未完成（false）。
寻找一个满足以下条件的进程 ( P_i )：
- ( \text{Finish}[i] = \text{false} )
- ( \text{Need}[i] \leq \text{Work} )
若找到 ( P_i )，则假设其执行完毕并释放资源：
- ( \text{Work} = \text{Work} + \text{Allocation}[i] )
- ( \text{Finish}[i] = \text{true} )
重复步骤 2~3，直到所有进程标记为完成（安全）或找不到满足条件的进程（不安全）。

2. 资源请求算法

当进程 ( P_i ) 请求资源时，按以下步骤处理：

若请求量 ( \leq \text{Need}[i] )，继续；否则视为错误。
若请求量 ( \leq \text{Available} )，继续；否则让 ( P_i ) 等待。
试探性分配：
- ( \text{Available} = \text{Available} - \text{Request} )
- ( \text{Allocation}[i] = \text{Allocation}[i] + \text{Request} )
- ( \text{Need}[i] = \text{Need}[i] - \text{Request} )
执行 安全性检查：
- 若安全，则正式分配资源；
- 若不安全，撤销试探性分配并让 ( P_i ) 等待。

四、实例演示

假设系统有 3 种资源（A, B, C），总量为 ( (10, 5, 7) )，当前分配状态如下：

进程	Allocation (A,B,C)	Max (A,B,C)	Need (A,B,C)	Available (A,B,C)
P0	(0,1,0)	(7,5,3)	(7,4,3)	(3,3,2)
P1	(2,0,0)	(3,2,2)	(1,2,2)
P2	(3,0,2)	(9,0,2)	(6,0,0)
P3	(2,1,1)	(2,2,2)	(0,1,1)
P4	(0,0,2)	(4,3,3)	(4,3,1)

步骤 1：安全性检查

初始 Work = Available = (3,3,2)
寻找 Need ≤ Work 的进程：
- P1：Need=(1,2,2) ≤ (3,3,2) → 分配后 Work = (3,3,2) + (2,0,0) = (5,3,2)
- P3：Need=(0,1,1) ≤ (5,3,2) → Work = (5,3,2) + (2,1,1) = (7,4,3)
- P4：Need=(4,3,1) ≤ (7,4,3) → Work = (7,4,3) + (0,0,2) = (7,4,5)
- P0：Need=(7,4,3) ≤ (7,4,5) → Work = (7,4,5) + (0,1,0) = (7,5,5)
- P2：Need=(6,0,0) ≤ (7,5,5) → Work = (7,5,5) + (3,0,2) = (10,5,7)

安全序列：P1 → P3 → P4 → P0 → P2，系统处于安全状态。

步骤 2：处理资源请求
假设 P1 请求 (1,0,2)：

检查合法性：
- Request=(1,0,2) ≤ Need[1]=(1,2,2) ✔️
- Request=(1,0,2) ≤ Available=(3,3,2) ✔️
试探性分配：
- Available = (3,3,2) - (1,0,2) = (2,3,0)
- Allocation[1] = (2,0,0) + (1,0,2) = (3,0,2)
- Need[1] = (1,2,2) - (1,0,2) = (0,2,0)
执行安全性检查，发现仍存在安全序列（例如 P1 → P3 → P4 → P0 → P2），因此正式分配资源。