###
操作系统中
进程调度与安全状态判定
#### 安全状态定义
在
操作系统理论中，当
系统的当前
资源分配状况能够找到至少一种顺序，在这种顺序下所有
进程都能顺利完成执行，则认为此状态下
系统处于安全状态。反之则称为不安全状态。
#### 银行家算法应用实例解析
针对给出的具体场景——即有五个
进程(P
0至P
4)，以及
三种类型的
资源(A, B, C)：
- **初始条件**
- 可用
资源数量分别为A=
1,B=6,C=
2,D=
2。
|
进程 | 已分配
资源 (Allocation)| 所需额外
资源 (Need) |
|---|---|---|
| P
0 |
0 0 3 2 |
0 0 1 2 |
| P
1 |
1 0 0 0 |
1 7 5
0 |
| P
2 |
1 3 5
4 |
2 3 5 6 |
| P
3 |
0 3 3 2 |
0 6 5
2 |
| P
4 |
0 0 1 4 |
0 6 5 6 |
通过构建工作向量Work并尝试寻找可能的工作路径来验证是否存在一个可行的安全序列[^
2]。
经过计算得出结论：存在一条有效的安全序列<P
0,P
3,P
4,P
1,P
2>，因此可以断言在这个配置条件下
系统确实位于安全区域内。
#### 请求处理评估
假设现在收到来自P
2的新请求(Request=[
1,
2,
2,
2])，为了决定是否应该批准这个新的
资源申请，需要再次模拟整个过程，并考虑如果给予这些
资源之后剩余可利用的
数量是否会使得其他等待中的任一
进程也无法继续运行下去而陷入僵局。
一旦按照上述
假定进行了更新后的重新测试发现剩下的可用
资源不足以支持任何未完成的任务进一步获取所需
资源直至结束其生命周期的话，那么显然这样的决策将会把
系统带入到危险境地；具体来说就是剩下(
0,
4,
0,
0)单位的闲置
资源明显不足以为后续操作提供保障，所以应当拒绝此次请求以免造成潜在的风险。
```python
def banker_algorithm(allocation_matrix, max_demand_matrix, available_resources, request_vector=None)
:
n_processes = len(allocation_matrix)
work = list(available_resources)
finish = [False] * n_processes
while not all(finish)
:
found_safe_process = False
for i in range(n_processes)
:
if not finish[i]
:
need_i = []
for j in range(len(max_demand_matrix[i]))
:
need_i.append(max_demand_matrix[i][j]-allocation_matrix[i][j])
can_be_allocated = True
for k in range(len(work))
:
if need_i[k]>work[k]
:
can_be_allocated=False
if can_be_allocated and ((request_vector is None) or all([need_i[l]>=request_vector[l] for l in range(len(request_vector))]))
:
# Add allocated resources back to the pool when process finishes.
for m in range(len(work))
:
work[m]+=allocation_matrix[i][m]
finish[i]=True
found_safe_process=True
if not found_safe_process
:
break
return all(finish), work
# Example usage with provided data points
allocations = [[
0,
0,
3,
2],[
1,
0,
0,
0],[
1,
3,5,
4],[
0,
3,
3,
2],[
0,
0,
1,
4]]
max_demands=[[
0,
0,
1,
2], [
1,7,5,
0], [
2,
3,5,6], [
0,6,5,
2], [
0,6,5,6]]
avail_res=[
1,6,
2,
2]
req_vec_P
2=[
1,
2,
2,
2]
is_system_safe_before_request, _ = banker_algorithm(allocations,max_demands, avail_res)
print("Is system safe before new resource allocation
:", "Yes" if is_system_safe_before_request else "No")
_, remaining_after_allocation_to_p
2 = banker_algorithm(
allocations,
max_demands,
[a-r for a,r in zip(avail_res, req_vec_P
2)],
req_vec=req_vec_P
2
)
if any(x<
0 for x in remaining_after_allocation_to_p
2)
:
print("System would enter unsafe state after allocating requested resources.")
else
:
_, final_state_post_alloc = banker_algorithm(
allocations,
max_demands,
[sum(pair)-r for pair,r in zip(zip(*allocations)[i]+tuple(req_vec_P
2), tuple(req_vec_P
2))]
)
print("Final availability post-allocation
:",final_state_post_alloc,"Safe?" ,all(final_state_post_alloc))
```
博客提及在T0时刻利用银行家算法进行安全性检查，并给出相关表格，但未展示表格具体内容。银行家算法是操作系统中用于避免死锁的重要算法。
扫一扫
1346
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
