13180 操作系统第八章进程同步机制与死锁开始13180 操作系统的学习过程，献给每一位拥有梦想的"带专人"， p

开始13180 操作系统的学习过程，献给每一位拥有梦想的"带专人"，

ps：有不正确的地方麻烦更新在评论区，我会一一修复 😅

第八章进程同步机制与死锁

1. 临界资源

临界资源：指计算机系统中需要互斥使用的硬件或软件资源，如外设、共享代码段、共享数据结构等

根本原因：在并发程序中共享了公共变量，使得程序的计算结果与并发程序执行的速度有关。这种错误的结果往往又是与时间有关的，所以，把它称为与时间有关的错误

程序的运行环境就存在资源共享问题

在多进程系统中，把计算机系统中资源共享的程度分成三个层次

互斥：多个进程不能同时访问同一资源
死锁：多个进程因相互等待对方占有的资源而陷入无限期等待的僵持状态
饥饿：一个进程由于长期得不到所需资源而无法向前推进的情况

2. 解决进程同步与互斥问题 - 平等协商

解决进程同步与互斥问题的方法有两种

由竞争各方平等协商
引入进程管理者，由管理者来协调竞争各方对互斥资源的使用

为了保证临界资源的正确使用，把对临界资源的访问过程分成 4 个部分

进入区：检查可否进入临界区，如果可以进入，则设置正在访问临界区标志
临界区：进程中访问临界资源的一段代码（一次只允许一个进程进入）
退出区：将正在访问临界区标志清除
剩余区：代码中其余部分

为了合理使用计算机系统中的资源，操作系统中采用的进程同步机制应遵循一下 4 条准则

空闲则入：

任何同步机制都必须保证任何时刻最多只有一个进程位于临界区。当有进程位于临界区时，任何其他进程不能进入临界区
忙则等待：

当已有进程处于其临界区时，后到达的进程只能在进入区等待
有限等待：

为了避免死锁等现象的出现，等待进入临界区的进程不能无限期地死等
让权等待：

对于因在进入区等待而不能进入临界区的进程，应释放处理机，转换到阻塞状态，已使其他进程有机会得到处理器的使用权。

进程互斥的软件方法：彼得松算法

进程互斥的硬件方法：TS 指令和 Swap 指令

主要思路是用一条指令完成读和写两个操作，因而保证读操作和写操作不被打断

TS 指令是读出指定标志后把该标志设置成 TRUE

Swap 指令是交换两个字（字节）的内容

硬件方法的优点：

适用范围广，适用于任意数目的进程，单处理器和多处理器环境完全相同
简单、含义明确，容易验证其正确性
支持多个临界区，一个进程内有多个临界区时，为每个临界区设置一个布尔变量

硬件方法的缺点：

进程在等待进入临界区时，处理机为忙等，不能实现让权等待
由于进入临界区的进程是等待进程中随机选择的，有些进程可能一直选不上，从而导致饥饿现象

3. 解决进程同步与互斥问题 - 信号量

前面的互斥算法都是平等进程之间的协商机制，它们存在的问题是平等协商无法解决的

操作系统从进程管理者的角度来处理互斥的问题，信号量就是操作系统提供的管理公有资源的有效手段

信号量机制所使用的 P、V 原语，所谓原语，只指执行中不被进程调度和执行打断的语句

信号量只能通过初始化和两个标准的原语（即 P 原语和 V 原语）

若信号量为非负整数值，则表示当前的空闲资源数

若信号量为负整数值，则其绝对值表示当前等待临界区的进程数

P 操作 申请资源 S = S -1 S < 0 等待状态（无资源）

助记：P 想象成 Parking，停车，等待

V 操作 释放资源 S = S + 1 S <= 0 $等待状态 \rightarrow 就绪状态$

助记：V 想象成 Vehicle，发信号，别等了，可以启动车辆继续行驶了

4. 进程同步与互斥

进程的同步：

一个进程要等待另一个进程执行完毕后才能执行

A 进程的信号量是 S2，B 进程的信号量是 S1

由于需要执行完 A 进程才能执行 B 进程，所以在 A 进程执行之前先对 B 进程进行刹车，所以 B 进程先执行 P（S1），A 进程中的把信息送入缓冲区的意思就是 A 进程已经执行完了，这时候通过踩油门 V（S1）唤醒 B 进程，同时为了保证 B 进程后续内容执行，所以要对 A 进程踩刹车 P（S2），在通过 V（S2）对 A 进程进行唤醒

进程的互斥：

同时只能有一个进程执行

A 进程与 B 进程同时进入，不想让两个进程争抢操作区

A 进程先刹车，此时 S = 1-1 =0 执行操作时如果 B 进程来捣乱，S 在小于 0 的时候才会进入等待状态，B 进程也执行了 S = 0 - 1 = -1，这时进程 B 无法抢占操作区

当 A 的操作执行完，执行 V（S），相当于踩油门 S = -1 + 1 = 0，这时可以执行 B

B 的操作执行完，执行 V（S），相当于踩油门 S = 0 + 1 = 1

注意：P、V操作在使用时必须成对出现

互斥在同一个进程，同步在不同进程。同时有同步和互斥，同步在前

5. 经典的进程同步问题

简单生产者-消费者问题

前提：缓冲区只能存放一个产品

生产者不能往已经满的缓冲区放入产品，设置信号量empty，初始值为 1，用于指示空缓冲区的数量
消费者不能从已经空的缓冲区中取出产品，设置信号量 full，初值为 0，用于指示满缓冲区的数量

多个生产者-消费者问题

同步问题

生产者进程不能往满的缓冲区中放入产品，设置信号量 empty，初始值为 k，用于指示缓冲池中空缓冲区数目

消费者进程不能从空的缓冲区中取出产品，设置信号量 full，初始值为 0，用于指示缓冲池中满缓冲区的数目
互斥问题

设置信号量 mutex，初值 1，用于实现临界区（环形缓冲池）的互斥

另设整形变量 i 和 j，初值均为 0

i 用于指示空缓冲区的头指针

j 用于指示有产品的满缓冲区的头指针

读者-写者问题

核心：读时不能写，写时不能读，读时可以读

说明：

mutex 和write 都是信号量，它们的初值都是 1，read_count 是一个共享变量，初值是 0，需要互斥使用，不能出错

如果第一个读者进入，就不能允许写者进入，

强调：这是写者 if(read_count = 1) p(write) 语句的作用

第一个读者负责禁止任何写者进入

以上这两个操作都需要放在互斥区内

而其他读者可以随着第一个读者进入陆续进入
当有读者完成读操作之后，相应地要对read_count 进行减一操作。而且如果read_count = 0，表明已没有读者了，写者可以随时进入

对于读者来说，只要有一个写者已经在临界区执行写操作，所有读者必须等待 对于进程同步问题无法理解的同学，可以看一下 B 站博主德克说说看的P、V 大题相关解析

6. 死锁

是指在多道程序系统中的一种现象，一组进程中的每个进程均无限期地被该组进程中的另一个进程占有且永远不会释放的资源。系统发生这种现象称为系统处于死锁状态，简称死锁。系统发生死锁时，死锁进程的个数至少为两个

例如：进程 A 占有了资源 R1，等待资源 R2，而进程 B 占有了资源 R2，等待资源 R1，就会出现死锁

产生死锁的原因：

竞争资源，系统资源在分配时出现错误，进程间对资源的相互争夺而造成僵局
多道程序运行时，进程推进顺序不合理

按照资源的使用性质分类

永久性资源（可重用资源）
临时性资源（消耗性资源）

对于永久性资源，产生死锁的四个必要条件

互斥条件

资源是独占且排他使用。进程互斥使用资源，任意时刻，一个资源只能给一个进程使用，若其他进程请求一个资源，而该资源被另一个进程占有，申请者只能等待，直到资源被占用着释放为止
不可剥夺条件

又称不可抢占或不可强占。进程获得资源在未使用完毕之前，不能被其他进程强行剥夺，只能由获得该资源的进程自愿释放
请求和保持条件

又称部分分配或占有申请。进程先申请它所需的一部分资源，得到后再申请新的资源，再申请新的资源的同时，继续占有已经分配到的资源
循环等待条件

又称环路等待。环路中一个进程已占有的资源被另一个进程所申请，即前一个进程占有后一个进程所请求的资源

重要：只要系统发生死锁，则以上四个条件一定成立

解决死锁的方法：

不让死锁发生（预防）
检测死锁是否发生，加以解决（解决）

7. 死锁的处理办法

死锁预防

方法是防患于未然

是指在任何系统操作前（例如分配资源和调度进程），事先评估系统的可能情况，严格采取措施使得死锁的四个必要条件不成立

静态分配策略：

一个进程在申请新资源的要求无法被立刻满足时，便处于等待状态，处于等待状态的进程的全部资源可以被剥夺，被剥夺的资源重新加入资源表中，当该进程重新获得它原有资源或得到新申请资源才可以重新启动，破坏了不可剥夺条件（听微信语音的时候电话来了）
资源有序分类策略

基本思想：将系统中所有资源顺序编号，一般原则是，较为紧缺、稀少的资源编号较大。

即一个进程只有得到编号小的资源，才能申请编号较大的资源；资源释放时，应按编号递减的次序进行。

采用资源有序分配策略，破坏了死锁的循环等待条件

死锁避免

基本思想：系统对进程发出的每一个系统能够满足的资源申请进行动态检查，并根据检查结果决定是否分配资源，如果分配后系统可能发生死锁，则不予分配，否则予以分配

最著名的死锁避免算法是：银行家算法

死锁避免和死锁预防的区别：

死锁预防是设法至少破坏产生死锁的四个必要条件之一，严格地防止死锁的出现

死锁避免是在系统运行过程中注意避免死锁的最终发生

银行家算法计算题

如果操作系统能保证所有的进程在有限时间内得到需要的全部资源，则称系统处于安全状态，否则说系统是不安全的

所谓安全状态是指，如果存在一个由系统中所有进程构成的安全序列{P1 , … , Pn}，则系统处于安全状态

如果不存在任何一个安全序列，则系统处于不安全状态

系统处于安全状态则不会发生死锁

系统若处于不安全状态则可能会发生死锁

8. 哲学家就餐问题

核心：前四个哲学家拿左筷子，第五个哲学家拿右筷子

练习

一组进程在并发执行时，可能会出现与时间有关的错误，产生这一现象的原因不包括
1. 这些进程的推进顺序不确定
2. 这些进程的执行速度不由进程自身控制
3. 这些进程互斥低使用了公共变量
4. 这些进程随时可能被中断，且断点不固定
智能手机上电话和微信语音不能同时使用，这提现了
1. 进程的死锁
2. 进程的同步
3. 进程的互斥
4. 进程的并发
并发进程运行时产生与时间相关的错误的根本原因在于
1. 执行速度不由进程自身控制
2. 程序执行中被中断
3. 程序使用了各自的变量
4. 程序中共享了公共变量
某电脑只连接了一台打印机，则 WORD 应用中完成打印的代码属于
1. 临界区
2. 同步区
3. 死锁区
4. 危险区
信号量 S 的初始值为 5，对 S 进行 3 次 P 操作和 4 次 V 操作后，S 的值为
1. 3
2. 4
3. 4
4. 6
下面描述中不正确的是
1. P、V 操作都是原语操作
2. 利用信号量的P、V操作可以交换大量信息
3. 用 P、V 操作可以实现进程间的同步
4. 用 P、V 操作可以解决任何进程的互斥问题
分析：P、V 操作主要是用于控制进程对资源的访问，而不是用于大量交换信息的
静态资源分配策略在解决死锁问题中用于
1. 死锁预防
2. 死锁避免
3. 死锁检测
4. 死锁解除
以下关于死锁的四个必要条件的说法中，不正确的是
1. 死锁必要条件只要有一个条件成立，系统就会发生死锁
2. 死锁必要条件只要有一个不成立，系统就不会出现死锁
3. 死锁必要条件同时成立，系统也不一定会出现死锁
4. 系统发生死锁时，死锁四个必要条件一定同时成立
在 Android 手机中，接电话应用永远都可以畅通运行，对此该系统所采用的死锁预防措施是打破死锁必要条件中的
1. 互斥条件
2. 请求和保持条件
3. 循环等待条件
4. 不可剥夺条件
三个进程 A、B、C 对某类资源的需求量分别是 7 个、8 个和3 个，且目前三个进程已分别得到了 3 个、3 个和 2 个。为保证系统的安全，该系统目前剩余的资源至少是
1. 1 个
2. 2 个
3. 5个
4. 10 个
A、B、C 分别需要 4、5、1
下列关于安全状态与死锁状态的说法中，错误的是
1. 安全状态不会发生死锁
2. 不安全状态一定会导致死锁
3. 死锁状态一定是不安全状态
4. 状态是否安全与死锁存在一定关系
对资源按照其紧缺稀少程度进行编码，当进程申请资源时按资源编号从小到大的顺序申请，释放资源时按从大到小的顺序释放。这种死锁预防措施，是打破死锁必要条件中的
1. 互斥条件
2. 循环等待条件
3. 不可剥夺条件
4. 请求和保持条件
产生死锁的原因主要有竞争资源和推进顺序不合理

《操作系统》课程的期末考试即将举行，假设把学生和监考老师都看作进程，学生有 N 人，教师 1 人。考场门口每次只能进出一个人，进考场的原则是先来先进。当N 个学生都进入考场后，教师才能发卷子

信号量及其他变量定义如下：

Semaphore S_Door；能否进出门，初值为 1

Semaphore S_StudentReady; 学生是否到齐，初值为 0

int nStudentNum = 0；学生数目

Semaphore S_Mutex；互斥信号量，初值为1

请说明学生与教师两个进程之间的同步与互斥关系

同步关系：N 个学生都进入考场以后，教师才能发卷子

互斥关系：考场门口每次只能进出一个人

以下是用信号量 P、V 操作实现学生与教师两个进程的同步程序。请补充题目中的 P、V 操作，按空格中的顺序，将答案写在答题纸上

// 学生进程
{
 1: P(S_Door) // 学生进程要进门，先申请对门口资源的访问权限，即执行 P 操作
 // 进门
 2: V(S_Door) // 学生进程进门后，释放对门口的占用，执行 V 操作，以便其他学生或监考教师可以使用门口
 3: P(s_Mutex) // 保证对 nStudentNum 的操作时互斥的，执行 P 操作，防止多个学生进程同时修改 nStudentNum 导致数据不一致
 nStudentNum ++; // 增加学生个数
 if(nStudentNum == N)
   4: V(S_StudentReady) // 表示学生都已到齐，执行 V 操作，唤醒等待在 S_StudentReady 上的教师进程，让教师可以发卷子
 5: V(S_Mutex) // 保证对 nStudentNum 的操作是互斥的，执行 V 操作，以便其他学生进程可以获取该信号量进行对nStudentNum 的操作
}

// 教师进程
{
  6: P(S_Door) // 教师进程要进门，同样先申请对门口资源的访问权，执行 P 操作
  // 进门
  7: V(S_Door) // 教师进门口，释放对门口的占用，执行 V 操作
  8: P(S_StudentReady) // 等待最后进门学生来唤醒 教师进程执行到这里，需要等待学生都到齐的信号，即执行 P 操作
  // 发卷子
}

某虚拟体验馆可以容纳 50 人同时参观体验。参观者进入体验馆时需要登记个人信息，离开时需要撤销登记。以下程序使用 P、V 操作描述了参观者进程的同步关系。补充程序中的 P、V 操作，将编号 1-5 处空缺的内容填写在答题卡上。

semaphore R = 1; // 登记表的互斥操作
semaphore S = 50; // 参观者之间的同步操作

Process_Visitor() {
  1: P(S) // 进来一个参观者 对应 19 行同步模型
    
  // 8-10 行是登记的互斥模型   
  P(R);   // P(R) 是一个互斥操作，同步与互斥同步在先 所以第一个空是一个同步操作
  Register(); // 在登记表上登记
  2: V(R) // 互斥模型 一个 P 一个 V 中间夹一个操作
  
  Visit(); // 进入体验馆参观体验
  
	// 15-17 行是撤销登记表的互斥模型  
  3: P(R)
  Unregister(); // 撤销登记表
  4: V(R) // 互斥模型 一个 P 一个 V 中间夹一个操作
  
  5: V(S); // 离开一个参观者
  Leave(); // 离开体验馆
}

设有 6 个进程P1、P2、P3、P4、P5、P6，它们有如图所示的并发关系。回答：

这里有几组同步关系？请分别描述

p1 p2, p1 p3, p2 p4, p3 p5, p4 p6, p5 p6

以下是用信号量 P、V 操作实现的六个进程的同步程序，请补充题目中的 P、V 操作，按空格中的顺序，将答案写在答题卡上

（用 4 个信号量分别用于进程同步，初值为 0，每个信号量表示图中一个结点所涉及的同步关系）

 semaphore:s1,s2,s3,s4;
 s1=0;s2=0;s3=0;s4=0;
 process P1() {
   ...
   1: V(S1)// 唤醒 P2
   2: V(S1)// 唤醒 P3
 }

 process P2() {
   3: P(S1)// 等待 P1
   ...
   4: V(S2)// 唤醒 P4
 }

 process P3() {
   5: P(S1)// 等待 P1
   ...
   6: V(S3)// 唤醒 P5
 }

 process P4() {
   7: P(S2)// 等待 P2
   ...
   8: V(S4)// 唤醒 P6
 }

 process P5() {
   9: P(S3)// 等待 P3
   ...
   10: V(s4)// 唤醒 P6
 }

 process P6() {
   11: P(S4)// 等待 P4
   12: P(S4)// 等待 P5
   ...
 }

设有两个优先级相同的进程 User1 与 User2，试对他们的代码添加 P、V 操作，使User1 与 User2 的同步关系满足语序：W1、V1、V2、V3、W2 的要求，所用信号量应给出初值，并完整写出添加 P、V 操作后的进程 User1 与 User2

semaphore s1=0,s2=1:0 ;
// User1 进程
while(true) {
  W1: X = A + 1;
  V(s1); 
  2: P(S2)
  W2: X = X + A;
  // 打印 X 的值
  Y = Y + X;
}

// User2 进程
while(true) {
  Y = A;
  3: P(S1) // 
  V1: Y = X + B;
  v2: 打印 Y 的值
    
  V3： X = A + 2
  4: V(S2)
}

企业注册与缴费问题描述如下：企业法人到工商所准备注册，注册员给企业法人开具缴费单，企业法人凭缴费单到财务室缴费，缴费成功后，财务室给企业法人出具发票，企业法人凭发票到注册员处取执照。
1. 说明注册与缴费两个进程之间的同步关系
  
  开具了缴费单才能缴费，开具了发票才能发执照
2. 设置两个信号量invoice 和 payment，初始值均为 0，invoice 表示发票，payment 表示缴费单。以下是用信号量 P、V 操作实现的注册与缴费两个进程的同步程序。补充题目中的 P、V 操作，将编号 1-4 处空缺的内容填写在答题卡上
```
// 注册进程
{
  ...
  // 开具缴费单；
  1: V(payment)
  2: p(invoice)
  // 发执照；
  ...
}

// 缴费进程
{
  ...
  3: P(payment)
  // 开具发票
  4: V(invoice)
  ...
}
```

桌上有一空盘，只允许放一个水果，爸爸可向盘中放苹果，也可向盘中放橘子，儿子转等吃盘中的橘子，女儿专等吃盘中的苹果。规定当盘空时一次只能放一个水果供吃者取用。请补充题目中 P、V 操作，实现爸爸、儿子、女儿间的同步与互斥关系，并按空格中的顺序，将答案写在答题卡上

semaphore s1 = 1; // 控制爸爸放水果
semaphore s2 = 0; // 控制女儿取苹果
semaphore s3 = 0; // 控制儿子取橘子
// 爸爸进程
while(true) {
  P(s1);
  if(放入的是苹果) V(s2) // 允许女儿取苹果
  else 1: V(s3) // 允许儿子取橘子
}

// 女儿进程
while(true) {
  2: P(s2) // 等待苹果被放入
  // 从盘中取苹果
  3: V(s1) // 通知爸爸可以再放水果
}

// 儿子进程
while(true) {
  4: P(s3) // 等待橘子被放入
  // 从盘中取橘子
  5: V(s1) // 通知爸爸可以再放水果
}

有三组并发进程：读者、写者和管理者，它们共享一组数据区，大小为 N，写者每次写入一个单位的数据，管理者每次删除一个单位的数据，允许多个读者同时执行读操作；不允许读者、写者、管理者同时操作；有写者等待时，如有其它读者正在读，则新读者也可以读（即读优先）；不允许多个写者同时操作；写满后必须等待管理者删除。写者操作前首先检查是否有空间，管理者操作前首先检查是否有数据。

要求：
1. 说明三组进程之间的同步或互斥关系
  
  读者、写者、管理者是互斥的
  
  写者需要有空间，管理者需要等待是否有数据可以删除
2. 以下是用信号量 P、V 操作实现的读者、写者和管理者三个进程的同步程序。补充题目中的 P、V 操作，将编号 1-8 处空缺内容填写在答题卡上。
  
  全局变量readcount 和四个信号量s1、s2、w、mutex 的定义如下：
  
  readcount 表示正在读的读者数目，初始值为 0
  
  s1 表示空数据区的大小，初值为数据区的大小 N
  
  s2 表示已用数据区的大小，初值为 0
  
  w 用于读者、写者和管理者之间、写者和写者之间、管理者和管理者之间的互斥，初值为 1
  
  mutex 用于对 readcount 这个临界资源的互斥访问，初值为 1
```
// 读者
while(1) {
  P(mutex); // 申请访问readcount临界资源
  readcount ++; // 记录当前读者数量
  if(readcount == 1) P(w); // 如果当前是第一个读者，阻止写者与管理者进入
  V(mutex); // 释放对readcount的访问权
  // 读数据
  P(mutex); // 申请访问readcount临界资源
  readcount --; // 读者数量减少
  if(readcount == 0) V(w); // 如果是最后一个读者，释放写者或管理者的进入权
  V(mutex); // 释放对readcount临界资源
}

// 写者
while(1) {
  1: P(s1) // 检查是否有可用空间
  2: P(w) // 保证写者互斥，并防止读者这访问
  // 写入数据
  3: V(w) // 释放互斥，允许其他进程操作
  4: V(s2) // 写完后已用数据区+ 1 通知管理者可以删除
}

// 管理者
while(1) {
  5: P(s2) // 检查数据区是否有数据可以删除
  6: P(w) // 管理员与读者、写者互斥
  // 删除数据
  7: V(w) // 释放互斥，允许其他进程操作
  8: V(s1) // 删除完成后，空数据区+ 1 通知写者可以写入
}
```

简单做法就是根据互斥模型，读者进程中 5 行与 10 行是一个互斥模型，互斥模型都是互斥语句中间夹一个操作，已经知道读者、管理者和写者都是互斥的，那么应该有三组互斥模型，可以得到第二个空、第三个空、第六个空、第七个空都是互斥的，W是三种权限的互斥信号量

剩余第 1、4、5、8 空就是同步模型，

写者写入前需要检查是否有可用空间，信号量s1 表示空数据区大小，所以第一个空要先等待检查空数据区大小，

管理者需要先检查已经使用数据区的大小，信号量s2 表示已经使用数据区大小，所以第五个空要先等待检查已经使用数据区

第四个空则是写者操作完成需要调用管理者

第八个空则是管理者操作完通知读者可以写入

假如系统中有 5 个进程{P1、P2、P3、P4、P5}和 3 种类型资源 {A、B、C}，T0 时刻系统的资源分配情况如下表所示

进程目前占有量
A B C 最大需求量
A B C 剩余资源量
A B C
P1 2 1 2 5 5 9 2 3 3
P2 4 0 2 5 3 6
P3 4 0 5 4 0 11
P4 2 0 4 4 2 5
P5 3 1 4 4 2 4
1. 计算 T0 时刻每个进程尚需的资源量
  
  最大需求量 - 目前占有量
  
  P1 = [5, 5 ,9] - [2 , 1 ,2] = [3, 4 ,7]
  
  P2 = [5, 3 ,6] - [4, 0 ,2] = [1, 3 ,4]
  
  P3 = [4, 0 ,11] - [4, 0 ,5] = [0, 0 ,6]
  
  P4 = [4, 2 ,5] - [2, 0 ,4] = [2, 2 ,1]
  
  P5 = [4, 2 ,4] - [3, 1 ,4] = [1, 1 ,0]
2. 找出 T0 时刻的一个安全序列
  
  P4：剩余资源量 (2 3 3) > 资源请求 (2 2 1)，释放后 2 3 3 + 2 0 4 = 4 3 7 剩余量 + 占有量
  
  P5：剩余资源量 (4 3 7) > 资源请求 (1 1 0)，释放后 4 3 7 + 3 1 4 = 7 4 11
  
  P1：剩余资源量 (7 4 11) > 资源请求 (3 4 7)，释放后 7 4 11+ 2 1 2 = 9 5 13
  
  P2：剩余资源量 (9 5 13) > 资源请求 (1 3 4)，释放后 9 5 13 + 4 0 2 = 13 5 15
  
  P3：剩余资源量 (13 5 15) > 资源请求 (0 0 6)，释放后 13 5 15 + 4 0 5 = 17 5 20
  
  安全序列为 P4、P5、P1、P2、P3 安全序列非唯一
3. 若 T0 时刻，P2 提出资源请求(0、3、4)，能否将资源分配给它？为什么？
  
  P2 不能获得资源
  
  因为，资源请求 (0, 3 ,4) > 剩余资源量 (2, 3 ,3)，所以系统不能将资源分配给它，P2 必须等待
4. 若 T0 时刻，P4 提出资源请求(2、0、1)，能否将资源分配给它？为什么？
  
  P4 可以获得资源
  
  因为资源请求 (2, 0, 1) < 剩余资源量 (2, 3, 3)
  
  对 P4 请求进行试分配后，发现一个安全序列 P4、P5、P1、P2、P3，所以，实施分配后系统依然是安全的

进程	目前占有量 A B C	最大需求量 A B C	剩余资源量 A B C
P1	2 1 2	5 5 9	2 3 3
P2	4 0 2	5 3 6
P3	4 0 5	4 0 11
P4	2 0 4	4 2 5
P5	3 1 4	4 2 4

捏捏捏捏捏捏捏捏捏捏捏

笔者观看的课程是 B 站博主小飞学长Pro的课程，前四章是免费的如果需要看后面的建议大家去购买正版课程 😊😊

🎉 🎉 🎉 🎉 🎉 🎉 🎉 🎉 🎉 🎉 🎉 🎉 🎉 🎉 🎉 🎉 🎉 🎉 🎉 🎉 🎉 🎉 🎉 🎉

13180 操作系统 第八章 进程同步机制与死锁

第八章 进程同步机制与死锁