【计算机操作系统：五、资源分配与调度】

死锁是指多个进程因争夺资源而相互等待，无法继续执行的现象。死锁的典型例子：进程A占有资源1，等待资源2；进程B占有资源2，等待资源1；两个进程都无法继续执行。

weixin_43086101

1556人浏览 · 2025-01-10 15:13:47

weixin_43086101 · 2025-01-10 15:13:47 发布

5.1 资源管理概述

资源管理是操作系统的一项核心功能，其目的是在多任务环境中高效利用有限的计算机资源，保障系统的公平性和性能。资源包括硬件资源（如CPU、内存、I/O设备）和软件资源（如文件、进程控制块等）。操作系统通过资源分配策略，确保各个任务能够合理使用资源，同时避免冲突和浪费。

5.1.1 资源管理的目的和任务

资源管理的主要目的是：

公平性：确保所有用户和任务在资源分配上不受歧视。
高效性：最大化系统资源的利用率。
可靠性：通过合理的资源分配，避免死锁和其他系统故障。
灵活性：支持动态分配资源，以适应不同的任务需求。

操作系统的资源管理任务包括：资源分配、回收、调度，以及监控资源使用情况等。

5.1.2 虚拟资源

虚拟资源是操作系统通过抽象和虚拟化技术为用户提供的资源视图。例如：

虚拟内存：通过分页或分段技术将物理内存扩展为用户可感知的更大内存空间。
虚拟处理器：在多任务操作系统中，每个任务都认为自己独占CPU。

虚拟资源提高了资源的利用效率，并提供了更友好的用户体验。

5.2 资源管理的机制和策略

5.2.1 资源分配机制

资源分配机制决定了操作系统如何将资源分配给进程或任务。常见的资源分配机制包括：

静态分配：在任务开始前一次性分配资源。
动态分配：根据任务执行的需要，动态分配资源。
优先级分配：根据任务的优先级决定资源的分配顺序。

5.2.2 资源分配策略

资源分配策略是分配机制的具体实现方案，包括：

先到先服务（FCFS）：按照请求到达的顺序分配资源。
最短任务优先（SJF）：优先分配资源给运行时间最短的任务。
时间片轮转：为每个任务分配一个时间片，轮流使用资源。

5.3 死锁

5.3.1 死锁的定义与例子

死锁是指多个进程因争夺资源而相互等待，无法继续执行的现象。死锁的典型例子：

进程A占有资源1，等待资源2；
进程B占有资源2，等待资源1；
两个进程都无法继续执行。

5.3.2 产生死锁的原因和必要条件

死锁产生的必要条件有以下四点：

互斥：资源不能同时被多个进程使用。
占有并等待：进程已占有资源，同时等待其他资源。
不可剥夺：资源不能被强行夺取。
环路等待：进程之间形成资源的循环等待。

5.3.3 系统模型和死锁的处理

操作系统应通过以下方法处理死锁：

死锁预防：通过破坏死锁的必要条件来防止死锁。
死锁避免：动态检测资源分配状态，确保系统不会进入死锁状态（如银行家算法）。
死锁检测与恢复：定期检测死锁，发现后通过回收资源等方式恢复系统。

5.3.3.1 示例：银行家算法

银行家算法用于动态分配资源，避免系统进入死锁状态。

\# 银行家算法的基本实现
available \= \[3, 3, 2\] \# 可用资源
max\_need \= \[\[7, 5, 3\], \[3, 2, 2\], \[9, 0, 2\], \[2, 2, 2\], \[4, 3, 3\]\] \# 最大需求
allocation \= \[\[0, 1, 0\], \[2, 0, 0\], \[3, 0, 2\], \[2, 1, 1\], \[0, 0, 2\]\] \# 已分配
need \= \[\[7, 4, 3\], \[1, 2, 2\], \[6, 0, 0\], \[0, 1, 1\], \[4, 3, 1\]\] \# 剩余需求

\# 检查是否安全
def is\_safe\_state():
work \= available\[:\]
finish \= \[False\] \* len(max\_need)
while True:
for i in range(len(max\_need)):
if not finish\[i\] and all(need\[i\]\[j\] <= work\[j\] for j in range(len(work))):
work \= \[work\[j\] + allocation\[i\]\[j\] for j in range(len(work))\]
finish\[i\] \= True
break
else:
break
return all(finish)
print("系统是否安全：", is\_safe\_state())

5.3.4 解决死锁问题的策略

死锁预防

操作系统可以通过以下措施预防死锁：

限制资源的独占使用，避免互斥。
要求进程在开始前申请所有资源，避免占有并等待。
允许抢占资源，打破不可剥夺条件。
对资源分配进行编号，强制线性申请，避免环路等待。

5.3.5 死锁的预防

死锁预防是通过约束系统的运行条件，从根本上避免死锁的发生。根据产生死锁的四个必要条件（互斥、占有并等待、不可剥夺、循环等待），死锁预防的核心在于打破这些条件之一。具体措施包括以下几个方面：

限制资源请求的顺序：

系统可以为资源分配设定严格的顺序规则，要求进程只能按照固定的顺序请求资源。例如，为所有资源编号，进程只能按资源编号递增的顺序申请资源，这样可以避免循环等待的产生。然而，此方法在实际应用中可能会限制系统的灵活性，导致资源利用率降低。
资源预先分配：

进程在执行前，必须一次性申请其需要的所有资源。如果资源无法满足请求，则进程需等待。这种方法有效避免了“占有并等待”条件，但代价是资源的利用率较低，因为有些资源可能被占用但未实际使用。
资源的可剥夺性：

系统设计可以允许高优先级进程剥夺低优先级进程的资源。如果某个进程的请求导致潜在的死锁，则系统可以强制剥夺其他进程已分配的资源并将其分配给当前进程，从而打破死锁的条件。
限制进程对资源的持有时间：

系统可以设置时间限制，要求进程在一定时间内释放所占有的资源。超过时间限制后，资源将被回收并重新分配。

图示：死锁预防的原理

以下图示展示了通过避免循环等待的资源分配顺序策略：

进程 P1 → 申请 R1 → 获得 R1 → 申请 R2 → 获得 R2 → 释放 R1、R2  
进程 P2 → 申请 R2 → 获得 R2 → 申请 R3 → 获得 R3 → 释放 R2、R3

代码示例：资源顺序分配策略

# 简单的资源分配顺序示例
resources = {'R1': False, 'R2': False, 'R3': False}  # 资源状态 False表示可用
def request_resources(process, requested_resources):
    for resource in requested_resources:
        if resources[resource]:  # 如果资源被占用
            print(f"{process} 等待资源 {resource}")
            return False
    for resource in requested_resources:
        resources[resource] = True  # 分配资源
        print(f"{process} 获得资源 {resource}")
    return True

def release_resources(process, allocated_resources):
    for resource in allocated_resources:
        resources[resource] = False  # 释放资源
        print(f"{process} 释放资源 {resource}")

# 示例运行
request_resources("P1", ["R1", "R2"])
release_resources("P1", ["R1", "R2"])

通过上述方法，死锁预防虽然增加了系统复杂性，但能够有效避免死锁的发生。

5.3.6 死锁的避免

死锁的避免是基于动态分析资源分配的安全性，在资源分配时确保系统能够保持安全状态。银行家算法是死锁避免的经典方法，其核心思想是通过模拟资源分配，计算系统是否能达到安全状态，从而决定是否满足资源请求。

银行家算法的核心原理：

银行家算法将资源分配问题类比为银行向客户发放贷款的过程，只有在确保所有客户能够在某种安全顺序下完成贷款偿还时，银行才会批准新的贷款请求。算法的关键步骤如下：

数据结构：
- Available[]：系统中剩余的可用资源数量。
- Max[][]：每个进程所需的最大资源数目。
- Allocation[][]：当前分配给各进程的资源数目。
- Need[][]：各进程尚需的资源数目，计算公式为 Need[i][j] = Max[i][j] - Allocation[i][j]。
安全性检查：
在分配资源前，算法会模拟分配操作，并检查是否存在一个进程序列，使得每个进程都能顺利完成并释放资源。若存在这样的序列，则系统处于安全状态。
资源分配策略：
- 若资源请求满足 Request[i][j] <= Need[i][j] 且 Request[i][j] <= Available[j]，则尝试分配资源；
- 若分配后系统进入不安全状态，则拒绝该请求。

银行家算法示例：

假设有三个进程 P1、P2 和 P3，以及三种资源 R1、R2 和 R3，其初始状态如下：

Available: [3, 3, 2]  
Max:       [[7, 5, 3], [3, 2, 2], [9, 0, 2]]  
Allocation: [[0, 1, 0], [2, 0, 0], [3, 0, 2]]  
Need:       [[7, 4, 3], [1, 2, 2], [6, 0, 0]]

通过银行家算法，可以判断资源是否能够安全分配。以下为 Python 实现：

代码示例：银行家算法

def is_safe_state(available, max_resources, allocation, need):
    work = available[:]
    finish = [False] * len(need)
    safe_sequence = []

    while True:
        found = False
        for i in range(len(need)):
            if not finish[i] and all(need[i][j] <= work[j] for j in range(len(work))):
                safe_sequence.append(i)
                work = [work[j] + allocation[i][j] for j in range(len(work))]
                finish[i] = True
                found = True
        if not found:
            break
    if all(finish):
        print(f"系统安全，安全序列为: {safe_sequence}")
        return True
    else:
        print("系统不安全")
        return False

# 示例数据
available = [3, 3, 2]
max_resources = [[7, 5, 3], [3, 2, 2], [9, 0, 2]]
allocation = [[0, 1, 0], [2, 0, 0], [3, 0, 2]]
need = [[7, 4, 3], [1, 2, 2], [6, 0, 0]]

is_safe_state(available, max_resources, allocation, need)