操作系统——2.进程管理

考纲
一、进程与线程
- 1、进程的概念和特征
- 2、进程的状态和转换
- 3、进程控制
- 4、进程的组织/结构
- 5、进程的(高级)通信
- 6、线程概念和多线程模型
二、处理机调度
- 1、调度的概念
- 2、调度的时机、切换和过程
- 3、进程调度方式（考过）
- 4、调度的基本准则
- 5、调度算法
- 6、必考最后一题算法
三、进程同步
- 1、基本概念
- 2、实现临界区互斥的基本方法。
- 3、信号量/PV操作
- 4、信号量应用
- 5、管程
- 6、经典同步问题
- - （1）生产者-消费者问题1
  - （2）生产者-消费者问题2
  - （3）读者-写者问题
  - （4）哲学家进餐问题
  - （5）吸烟者问题
  - （6）银行排队
  - （7）理发师问题
  - （8）驾驶员-售票员
四、死锁
- 1、死锁的概念
- 2、死锁的处理策略
- 3、死锁预防
- 4、死锁避免
- - （1）系统安全状态
  - （2）银行家算法
  - （3）安全性算法举例
  - （4）银行家算法举例
- 5、死锁检测和解除

考纲

进程: 进程控制块、进程的几种基本状态与状态转换（进程的创建、进程的终止、进程的阻塞与唤醒、进程的挂起与激活等）
进程的同步与互斥：临界资源、临界区、进程同步与互斥问题、信号量机制以及 P、V 操作、管程机制
进程间通信：进程通信的类型（直接通信和间接通信方式）、消息传递系统中的几个问题、消息缓冲队列通信机制
线程与进程的调度：线程与进程的基本概念，调度的类型、调度队列模型、调度方式、进程调度算法（先来先服务、短进程优先、时间片轮转、基于优先级的调度算法等）
死锁:死锁的基本概念，死锁定理、死锁预防、死锁避免与处理死锁的基本方法、银行家算法
综合应用：生产者消费者问题、读者和写者问题、哲学家进餐问题等

重要。+教材
进程与线程：选填。
处理机调度（典型调度算法）：简答。
进程同步（经典问题）：必考算法。
死锁：简答。

一、进程与线程

定义、特征、对比

1、进程的概念和特征

进程控制块PCB：为了使参与并发执行的程序（含数据）能独立地运行，为之配置的一个专门的数据结构。系统利用PCB来描述进程的基本情况和运行状态，进而控制和管理进程。
进程映像/进程实体内部结构：由程序段、相关数据段、PCB构成。有时简称进程。
创建进程→创建进程映像中的PCB。
进程映像/程序——静态；进程——动态。
PCB是进程存在的唯一标志。
进程：是进程实体的运行过程，是系统进行资源分配和调度的一个独立单位。
进程的特征：动态性（最基本）、并发性、独立性、异步性、结构性。

2、进程的状态和转换

状态：运行态、就绪态、阻塞态/等待态、创建态、结束态。（前三基本状态）
就绪队列：系统中处于就绪状态的进程的队列。
五种进程状态的转换：（会画）
- 就绪态→运行态：处于就绪态的进程被调度，获得处理机资源。
- 运行态→就绪态：时间片用完；或在可剥离的操作系统中、有更高优先级的进程就绪。
- 运行态→阻塞态：主动。进程请求资源使用或等待某一事件发生。
- 阻塞态→就绪态：被动。进程等待的事件到来。

3、进程控制

内核/CPU的操作、过程掌握。以PCB为线索。

进程控制功能：对系统中所有的所有进程实施有效的管理。
原语：进程控制用的程序段基本单位。特点：执行期间不允许中断。
阻塞原语和唤醒原语必须成对使用。
进程的创建：父进程创建子进程。创建原语如下：
- 1）分配进程标识号，申请一个空白PCB。（PCB有限，申请失败则创建失败）
- 2）分配资源、内存空间（PCB中体现）。（资源不足则处于阻塞态）
- 3）初始化PCB，包括标志信息、处理机状态信息、处理机控制信息、进程优先级。
- 4）如果可以，插入就绪队列。
进程的终止：正常结束、异常结束、外界干预。撤销原语如下：
- 1）根据标识符，检索PCB，读出进程状态。
- 2）终止执行，处理机资源分配给其他进程。
- 3）终止子孙进程。
- 4）归还资源给父进程或OS。
- 5）将该PCB从所在队列(链表)中删除。
进程的阻塞：运行→阻塞，被阻塞进程自我调用实现。
- 1）找到将要被阻塞进程的标识号对应的PCB。
- 2）保护现场，运行态转为阻塞态，停止运行。
- 3）将该PCB插入等待队列，处理机资源调度给其他。
进程的唤醒：被阻塞进程期待时间出现。由一个与被唤醒进程合作或被其它相关的进程调用实现。
- 1）等待队列找到PCB。
- 2）移出，置为就绪态。
- 3）该PCB插入就绪队列，等待调度。
进程的切换：环境信息改变。一般先有资源调度（决策行为），后有进程切换（执行行为）。
- 1）保存处理机上下文。
- 2）更新PCB信息。
- 3）把进程的PCB移入相应队列。
- 4）选择另一个进程执行，更新PCB。
- 5）更新内存管理的数据结构。
- 6）恢复上下文。

4、进程的组织/结构

※

进程的结构：进程控制块PCB、程序段、数据段。
PCB是进程存在的唯一标志。操作系统通过PCB表来管理和控制进程。
PCB作用：作为独立运行基本单位的标志；能实现间断性运行方式；提供进程管理所需要的信息；提供进程调度所需要的信息；实现与其他进程的同步与通信。
PCB结构（选填）：
1. 进程描述信息
2. 进程控制和管理信息
3. 资源分配清单：说明有关内存地址空间或虚拟地址空间情况，所打开文件的列表和所使用的IO设备信息。
4. 处理机相关信息：主要指处理机中各寄存器的值。
PCB组织方式：链接方式（队列）和索引方式（就绪/阻塞索引表）。

5、进程的(高级)通信

※，多种特点对比

共享存储：通过对共享空间进行r/w操作实现进程之间的信息交换。
1. 低级方式：基于数据结构的共享
2. 高级方式：基于存储区的共享
消息传递：进程通过系统提供的发送信息和接收消息两个原语进行数据交换。（报文）
1. 直接通信方式：挂在消息缓冲队列。
2. 间接通信方式/信箱通信方式：中间实体/信箱。相应的通信系统称为电子邮件系统。
管道通道（定义、结构）
1. 管道定义：用于连接一个读进程和一个写进程以实现它们之间的通信的一个共享文件。
2. 管道机制的协调能力：互斥、同步、确定对方的存在。
3. 管道可以克服使用文件进行通信的两个问题：限制管道的大小（不像文件不加检验的增长）、读进程可能比写进程快（解决read()调用返回文件结束）。
4. 管道只能采用半双工通信。
客户机-服务器系统
1. 套接字：网络通信接口。分类：基于文件型、基于网络型。优势：适用网络环境中不同计算机间的进程通信。
2. 远程过程调用RPC：通信协议，用于通过网络连接的系统。
3. 远程方法调用：RPC涉及面对对象编程。

6、线程概念和多线程模型

线程※

引入进程的目的：更好地使多道程序并发执行，提高资源利用率和系统吞吐量。
引入线程的目的：减少程序在并发执行时所付出的时空开销，提高操作系统的并发性能。
- 为什么要引入线程/好处/目的/特点：
线程结构：线程ID、程序计数器、寄存器集合、堆栈。
定义：线程是进程中的一个实体，是被系统独立调度和分派的基本单位。
线程基本状态：就绪、阻塞、运行。
线程和进程的比较（选填）：
1. 调度：引入线程的OS中，线程是独立调度的基本单位，进程是拥有资源的基本单位。上下文切换代价低。
2. 拥有资源：进程都是拥有资源的基本单位，线程可以访问其隶属进程的系统资源。
3. 并发性：不同进程的线程、相同进程的多个线程都可并发执行。
4. 系统开销：进程切换开销大于线程切换。同一进程内的多个线程共享进程的地址空间，无须OS干预。
5. 地址空间和其他资源：进程间相互独立，同一进程的线程共享资源，独立性更低。
6. 通信方面：进程间通信IPC需要进程同步和互斥手段的辅助，以保证数据的一致性。线程间可以直接r/w进程数据段来进行通信。
线程的属性/定义：
1. 线程是一个轻型实体，不拥有系统资源，但有标识符和线程控制块。
2. 不同的线程可以执行相同的程序，如不同用户调用。
3. 同一进程中的各个线程共享该进程所拥有的资源。
4. 线程是处理机的独立调度单位，多个线程可并发执行。
5. 线程：创建→生命周期（阻塞、就绪、运行）→终止。
线程的实现方式（了解能做什么操作）
1. 用户级线程：线程管理的所有操作由应用程序完成。应用程序可以通过使用线程库设计成多线程程序。
2. 内核级线程/内核支持的线程：由内核完成，应用程序只有一个接口。内核为进程及其内部的每个线程维护上下文信息，调度在内核基于线程架构的基础上完成。
多线程模型（优缺点概括）
1. 多对一模型：①优点：线程管理在用户空间进行，效率高。②缺点：一个线程阻塞→整个进程阻塞；多个线程不能并行运行。
2. 一对一模型：①优点：一个线程阻塞→另一个线程执行，并发强；②创建线程开销大，影响性能。
3. 多对多模型：特点：缺点都克服、优点都拥有。

二、处理机调度

进程调度，定义、应用

1、调度的概念

处理机调度：对处理机资源进行分配，以实现进程并发执行。是多道程序操作系统的基础、核心问题。
调度的层次
1. 高级调度/作业调度/用户调度/长程调度：内存与辅存之间的调度，分配资源、建立进程。调度对象：作业。多用于多道批处理系统。
2. 中级调度/内存调度：在外存的挂起态重新调入内存，修改为就绪态。（挂起态：把暂时不能运行的进程调至外存等待的进程状态。）
3. 低级调度/进程调度/OS调度/短程调度：按照某种方法和策略从就绪队列中选取一个进程将处理机分配。频率很高。对象：内核级线程/进程。
三级调度的联系（图掌握后大致印象）
1. 作业调度为进程活动做准备，进程调度使进程正常活动，中级调度将暂时不能运行的进程挂起。中级调度处于作业调度和进程调度之间。
2. 次数：作业调度＜中级调度＜进程调度。
3. 进程调度最基本。

2、调度的时机、切换和过程

进程调度和切换程序是操作系统内核程序。
不能进行进程的调度和切换的情况（选填）：等到结束后再进行。
1. 处理中断的过程中。
2. 进程在操作系统内核程序临界区中。
3. 其他需要完全屏蔽中断的原子操作过程中。
应该进行调度和切换的情况：（选填）
1. 非剥夺调度：发生引起调度条件且当前进程无法继续。
2. 剥夺调度：中断/自陷处理结束后，返回现场前可进行。

3、进程调度方式（考过）

※

非剥夺调度方式/非抢占方式：即使优先权更高的进程进入就绪队列，仍执行当前进程直到结束/阻塞态，才分配给新进程。优点：实现简单、系统开销小、适合多数批处理系统，不适合分时系统和大多实时系统。
剥夺调度方式/抢占方式：立即暂停当前进程，分配给新进程。优点：提高系统吞吐率和响应效率。“剥夺”遵循优先权、短进程优先、时间片原则等。

4、调度的基本准则

CPU利用率
CPU利用率=CPU有效工作时间CPU有效工作时间+CPU空闲等待时间CPU利用率=\frac{CPU有效工作时间}{CPU有效工作时间+CPU空闲等待时间}CPU利用率=CPU有效工作时间+CPU空闲等待时间CPU有效工作时间
系统吞吐量
周转时间：
周转时间=作业完成时间−作业提交时间周转时间=作业完成时间-作业提交时间周转时间=作业完成时间−作业提交时间
平均周转时间=sum(周转时间)/n平均周转时间=sum(周转时间)/n平均周转时间=sum(周转时间)/n
带权周转时间=作业周转时间作业实际运行时间带权周转时间=\frac{作业周转时间}{作业实际运行时间}带权周转时间=作业实际运行时间作业周转时间
平均带权周转时间=sum(带权周转时间)/n平均带权周转时间=sum(带权周转时间)/n平均带权周转时间=sum(带权周转时间)/n
等待时间。
响应时间。

共同目标：资源利用率、公平性、平衡性、策略强制执行。

5、调度算法

操作顺序、时间、特点

先来先服务调度算法FCFS
1. 应用：作业调度、进程调度。
2. 顺序：选择最先进入该队列的进程。不可剥夺算法。
3. 时间计算示例：
4. 特点：算法简单、效率低；长作业有利、短作业不利；CPU繁忙性作业有利、IO繁忙型作业不利。
短作业优先调度算法SJF
1. 应用：作业、进程。
2. 顺序：选取一个估计运行时间最短的进程。
3. 时间计算：平均等待时间、平均周转时间最少
4. 缺点：长作业不利、会产生“饥饿”（区分死锁：系统环形等待）；未考虑作业紧迫程度；必须预估作业运行时间；人机无法交互。
优先级调度算法PSA
1. 应用：作业、进程。
2. 顺序：优先级最高的进程。
3. 根据剥夺分类：非剥夺式优先级调度算法、剥夺式…。
4. 根据创建后优先级是否可变，分类进程优先级：
  1. 静态优先级：主要依据：进程类型、进程对资源的要求、用户要求。
  2. 动态优先级：主要依据：进程占用CPU时间的长短、就绪进程等待CPU时间的长短，
高响应比优先调度算法HRRN
1. 应用：作业
2. 顺序：响应比最高
3. 响应比：响应比Rp=等待时间+要求服务时间要求服务时间=响应时间要求服务时间响应比R_p=\frac{等待时间+要求服务时间}{要求服务时间}=\frac{响应时间}{要求服务时间}响应比Rp=要求服务时间等待时间+要求服务时间=要求服务时间响应时间
4. 优点：等待时间相同时，有利于短作业；要求服务时间相同时，先来先服务；对于长作业，响应比随等待时间的增加而提高，克服了饥饿，兼顾长作业。
时间片轮转调度算法RR
1. 应用：进程。（分时系统）
2. 顺序：FCFS策略，运行时间片后被剥夺到队尾。
3. 时间片大小对系统性能影响大。决定因素：系统响应时间、就绪队列中的进程数目、系统的处理能力。
4. 计算示例：
多队列调度算法
1. 应用：进程
2. 顺序：就绪队列拆分，不同队列应用不同算法。
3. 多处理机系统中易于为每个处理机单独设置就绪队列。
多级反馈队列调度算法
1. 应用：进程。
2. 调度机制：设置多个就绪队列；每个队列都采用FCFS算法，RR运行；按队列优先级调度。
3. 性能：较好的满足各种类型用户需要。
保证调度算法
1. 应用：进程。
2. 实现性能保证，如处理机分配的公平性。选择获得处理机比率（实际执行÷应获得时间）最小的进程运行。
公平分享调度算法
1. 应用：进程
2. 分配给每个用户相同的处理机时间。

6、必考最后一题算法

考法：不用完整实现代码，填空程序段即可
P1…Pn的描述、填空作业n的执行时间

eg.两道作业系统中：

三、进程同步

※

1、基本概念

理解

临界资源：一次仅允许一个进程使用的资源，如物理设备打印机、变量、数据。
临界区：访问临界资源的那段代码。
临界资源的访问结构：进入区（设置访问临界区的标志）、临界区/临界段、退出区（清除标志）、剩余区（其余部分）
同步/直接制约关系：为完成某种任务而建立的两个或多个进程，这些进程因为需要在某些位置上协调它们的工作次序而等待、传递信息所产生的制约关系。进程间的直接制约关系源于它们之间的相互合作。（考过，对比）
互斥/间接制约关系：当一个进程进入临界区使用临界资源时，另一个进程必须等待，当占用临界资源的进程退出临界区后，另一进程才允许访问此临界资源。
同步机制准则（考过）：空闲让进、忙则等待、有限等待、让权等待。

2、实现临界区互斥的基本方法。

有很多种，各自概念、特点对比

软件实现方法：设置标志
1. 单标志法：
  ①设置一个公用整型变量turn，用于指示被允许进入临界区的进程编号。
  ②两个进程必须交替进入临界区，否则违背“空闲让进”。
2. 双标志法先检查：
  ①先检查临界资源是否正被访问，设置flag。再置自己的标志。
  ②不用交替使用，可连续使用。可能同时进入临界区，违背“忙则等待”。问题出于检查和修改操作不能一次进行。
3. 双标志法后检查：
  ①先置自己的标志，再检查对方的状态标志。
  ②几乎同时想进入时，会互相谦让，导致“饥饿”。
4. Peterson‘s Algorithm：
  ①设置自己标志、turn、检测另一个进程状态标志、不允许进入标志。
  ②
硬件实现方法：/低级方法/元方法
1. 中断屏蔽方法：
  ①禁止一切中断发生，以防程序切换，使临界区代码顺利执行完。
  ②限制了处理机交替执行程序的能力，执行效率降低。
2. 硬件指令方法：
  1. TestAndSet指令：原子操作。读出指定标志后把该标志设置为真。利用该指令重复检查共享bool变量lock，直到进程退出。
  2. swap指令：利用该指令重复交换lock和key内容，检查key的状态。
3. 硬件方法优缺点：适用于任意数目的进程，支持有多个临界区，简单易验证。进入临界区耗费时间，不能实现让权等待；随机选择时可能导致饥饿。

3、信号量/PV操作

整型信号量：违背“让权等待”，进程处于“忙等”。
```
wait(S){       //Pwhile(S<=0);S=S-1;
}
signal(S){     //VS=S+1;
}
```

记录性信号量：遵循“让权等待”。加进程链表L，用于连接所有等待该资源的进程。

void wait(semaphore S){  //相当于申请资源S.value--;           //请求一个该类资源if(S.value<0){       //分配完毕add this process to S.L;block(S.L)       //自我阻塞，放弃处理机，插入该类资源的等待队列S.L}
}
void signal(semaphore S){//释放资源S.value++;           //释放一个资源，可分配+1if(S.value<=0){      //仍被阻塞remove a process P from S.L;wakeup(P);       //将S.L中第一个等待进程唤醒}
}

AND型信号量：将进程在整个运行过程中的所有资源一次性全部分配给进程，待进程使用完后再一起释放。在wait操作中加AND条件。
信号量集：信号量的测试值不再是1。（申请资源数不再是1）

4、信号量应用

同步（1、2、3种综合考）

semaphore S=0;           //初始化公共信号量
P1(){...x;                   //语句xV(S);                //告诉进程P2，语句x已经完成...
}
P2(){...P(S);                //检查语句x是否运行完成（S=0时，P2阻塞，执行完后再放回）y;                   //检查无误，运行y语句...
}

进程互斥：PV中间不能有冗余代码

semaphore S=1;           //初始化信号量（可用资源数）
P1(){...P(S);                //准备开始访问临界资源，加锁进程P1的临界区;V(S);                //访问结束，解锁...
}
P2(){...P(S);                //准备开始访问邻接资源，加锁进程P2的临界区;V(S);                //访问结束，解锁
}

前驱关系

示例：
设置S1→S2、S1→S3，信号量a1、a2。S2→S4、S2→S5：b1、b2。S3→S6：c。S4→S6：d。S5→S6：e。

semaphore a1=a2=b1=b2=c=d=e=0; //初始化信号量
S1(){...;V(a1); V(a2);              //S1已经运行完成
}
S2(){P(a1);                     //检查s1是否运行完成...;V(b1); V(b2);              //S2已经运行完成
}
S3(){P(a2);                     //检查s1是否运行完成...;V(c);                      //S3已经运行完成
}
S4(){P(b1);                     //检查s2是否运行完成...;V(d);                      //S4已经运行完成
}
S5(){P(b2);                     //检查s2是否运行完成...;V(e);                      //S5已经运行完成
}
S6(){P(c);                      //检查S3是否运行完成P(d);                      //检查s4是否运行完成P(e);                      //检查s5...;
}

分析进程同步和互斥问题的方法步骤

最后一个大题写完后最好加上这些描述来说明自己的思路
1. 关系分析。照吃问题中的进程数，分析他们之间的同步和互斥关系。同步、互斥、前驱按以上经典范式改写。
2. 整理思路。根据进程的操作流程确定P、V操作的大致顺序。
3. 设置信号量。设置需要的信号量、确定初值，完善整理。
4. 描述S2示例：它是S1后继，所以要用到S1资源，就要在L行为前P这种资源一下。S2是S4、S5的前驱，为他们提供资源，所以在L行为后面V由S4和S5代表的资源一下。

5、管程

考过选填

管程：定义了一个数据结构和在该数据结构上能为并发进程所执行的一组操作，这组操作能同步进程和改变管程中的数据。
管程结构：
①管程的名称
②局部于管程内部的共享结构数据说明
③对该数据结构进行操作的一组过程/函数
④对局部于管程内部的共享数据设置初始值的语句。
条件变量：一个进程被阻塞的原因，每个条件变量保存一个等待队列。（考应用）（选填）
1. x.wait：当x对应的条件不满足时，正在调用管程的进程调用x.wait将自己插入x条件的等待队列，并释放管程。此时其他进程可以使用该管程。
2. x.signal：x对应的条件发生了变化，则调用，唤醒一个因x条件二阻塞的进程。
3. 使用
```
monitor Demo{共享数据结构 S;condition x;                  //定义一个条件变量xinit_code(){...}take_away(){if(S<=0) x.wait();        //资源不够，在条件变量x上阻塞等待资源足够，分配资源，做一系列响应处理;}give_back(){归还资源，做一系列响应处理;if(有进程在等待) x.signal;  //唤醒一个阻塞进程}
}
```
1. 条件变量和信号量的比较
  ①相似点：wait/signal类似P/V操作，可以实现进程的阻塞/唤醒。
  ②不同点：条件变量仅实现了排队等待功能，信号量还可以反应剩余资源数，管程中剩余资源数用共享数据结构记录。

6、经典同步问题

最后一题，PV操作很多种，总结书上题型。所有PV操作的题，先分析，再做答，代码描述要加注释。

（1）生产者-消费者问题1

问题描述：生产和消费者共享一个缓冲区。只允许一个生产者放入、一个消费者取出消息。
问题分析：
①关系分析。即互斥又相互协作，也同步（生产者生产后，消费者才能消费）。
②整理思路。这两个进程存在互斥关系和同步关系，需要解决PV操作位置。
③信号量设置。信号量mutex作为互斥信号量，用于控制互斥访问缓冲池，互斥信号量初值为1，信号量full用于记录当前缓冲池中的满缓冲区数，初值为0，信号量empty用于记录当前缓冲池的空缓冲区数，初值为n。

描述

semaphore mutex=1;                //临界区互斥信号量
semaphore empty=n;                //空闲缓冲区
semaphore full=0;                 //缓冲区初始化为空
producer(){                       //生产者进程while(1){produce an item in nextp; //生产数据P(empty);(要用什么，P一下) //获取空缓冲区单元P(mutex);(互斥夹紧)        //进入临界区add nextp to buffer;(行为) //将数据放入缓冲区V(mutex);(互斥夹紧)        //离开临界区，释放互斥信号量V(full);(提供什么，V一下)   //满缓冲区数加1}
}
consumer(){                        //消费者进程while(1){P(full);                   //获取满缓冲区单元P(mutex);                  //进入临界区remove an item from buffer;//从缓冲区中取出数据V(mutex);                  //离开临界区，释放互斥信号量V(empty);                  //空缓冲区数加1consume the item;          //消费数据}
}

利用AND信号量解决生产者-消费者问题：用Swait(empty, mutex)代替wait(empty)和wait(mutex)；用Ssignal(mutex, full)代替signal(mutex)和signal(full)；用Swait(full, mutex)代替wait(full)和wait(mutex)；用Ssignal(mutex, empty)代替signal(mutex)和signal(empty)。

（2）生产者-消费者问题2

变体：爸爸提供水果1/2。教材解答P47#17

问题描述：桌上有一个盘子，每次只能向其中放入一个水果，爸爸专向盘子中放苹果，妈妈放橘子，儿子吃橘子，女儿吃苹果。只有盘子为空时才能放一个水果。
问题分析：
①关系分析：爸爸-妈妈互斥；爸爸-女儿、妈妈-儿子同步；儿子和女儿之间没有互斥和同步，是选择条件执行，不可能并发。

②整理思路：四个进程实际上可抽象为两个生产者和两个消费者被连接到大小为1的缓冲区上。
③信号量设置：首先将信号量plate设置互斥信号量，表示是否允许向盘子放入水果，信号量apple=1表示有苹果，orange=1表示有橘子。

代码：dad和daughter、mom和son必须连续执行

semaphore plate=1, apple=0, orange=0;
dad(){                                 //父亲进程while(1){prepare an apple;P(plate);                      //互斥向盘中取、放水果put the apple on the plate;    //向盘中放苹果V(apple);                      //允许取苹果}
}
mom(){                                 //母亲进程while(1){prepare an orange;P(plate);                      //互斥向盘中取、放水果put the orange on the plate;    //向盘中放橘子V(orange);                      //允许取橘子}
}
son(){                                  //儿子进程while(1){P(orange);                      //互斥向盘中取橘子take an orange from the plate;V(plate);                       //允许向盘中取、放水果eat the orange;}
daughter(){                             //女儿进程while(1){P(apple);                      //互斥向盘中取苹果take an apple from the plate;V(plate);                       //允许向盘中取、放水果eat the apple;}
}

（3）读者-写者问题

问题描述：有读者和写者两组并发进程，共享一个文件，同时读但不可同时写。要求：①允许多个读者可以同时读文件执行读操作；②只允许一个写者往文件中写信息；③任一写者在完成写操作之前不允许其他读者或写者工作；④写者执行写操作前，应让已有的读者和写者全部退出。
问题分析：
①关系分析：读者-写者互斥，写者-写者互斥，读者-读者不互斥。
整理思路
②整理思路：写者与任何进程互斥，读者在实现与写者互斥的同时实现与其他读者的同步，使用计数器判断当前是否有读者读文件，使写者无法写文件，且不同读者对计数器的访问也互斥。
③信号量设置：设置信号量count为计数器，记录当前读者数量。mutex为互斥信号量，用于保护更新count变量时的互斥。互斥信号量rw保证读者和写者互斥访问。

代码

//读进程优先：结果可能导致写进程长时间等待，且可能“饿死”
//写进程优先（读写公平法）
int count=0;                    //用于记录当前的读者数量
semaphore mutex=1;              //用于保护更新count变量时的互斥
semaphore rw=1;                 //用于保证读者和写者互斥地访问文件
writer(){                       //写者进程while(1){//P(w);                 //在无写进程请求时进入     P(rw);                  //互斥访问共享文件writing;                //写入V(rw);                  //释放共享文件//V(w);                 //恢复对}
}
reader(){                       //读者进程while(1){P(mutex);               //互斥访问count变量if(count==0)            //当第一个读进程读共享文件时P(rw);              //阻止写进程写count++;                //读者计数器加1V(mutex);               //释放互斥变量countreading;                //读取P(mutex);               //互斥访问count变量count--;                //读者计数器-1if(count==0)            //当最后一个读进程读完共享文件V(rw);              //允许写进程写V(mutex);               //释放互斥变量count}
}

（4）哲学家进餐问题

问题描述：哲学家只会思考和进餐，进食时试图拿起左、右两根筷子（一根一根拿起），只有同时拿到了两根筷子才开始进食。
问题分析：
①关系分析：5名哲学家与左右邻居对其中间筷子的访问是互斥关系。
②整理思路：本质是不造成死锁或饥饿，解决方法一是让他们同时拿两根筷子，二是对每名哲学家的动作制定规则。
③信号量设置：定义互斥信号量数组chopstick，哲学家编号为0~4。

代码：当一名哲学家左右两边的筷子都可用时，才允许他抓起筷子。

semaphore chopstick[5]={1,1,1,1,1};   //初始化信号量
semaphore mutex=1;                    //设置取筷子的信号量
Pi(){                                 //i号哲学家的进程do{P(mutex);                     //在取筷子前获得互斥量P(chopstick[i]);              //取左边筷子P(chopstick[(i+1)%5]);        //取右边筷子V(mutex);                     //释放取筷子的信号量eat;                          //进餐V(chopstick[i]);              //放回左边筷子V(chopstick[(i+1)%5]);        //放回右边筷子think;                        //思考}while(1);
}

（5）吸烟者问题

问题描述：一个供应者和三个抽烟者。每个抽烟者不停卷烟抽烟。抽烟者分别拥有三种材料：烟草、纸、胶水，供应者无限提供三种材料，供应者每次将两种材料放到桌上，拥有剩下那种材料的抽烟则可以卷烟抽烟，并给供应者一个完成信号，此时供应者会将另外两种材料放到桌上，让三个抽烟者轮流抽烟。
问题分析：
①关系分析：供应者和三个抽烟者分别是同步关系，抽烟者间互斥。
②整理思路：四个进程，供应者作为生产者向三个抽烟者提供材料。
③信号量设置：定义offer1/2/3分别标识xx组合的资源，信号量finish用于互斥进行抽烟动作。

代码：

int random;                        //存储随机数
semaphore offer1=0;                //定义信号量对应烟草和纸组合的资源
semaphore offer2=0;                //定义信号量对应烟草和胶水组合的资源
semaphore offer3=0;                //定义信号量对应纸和胶水组合的资源
semaphore finish=0;                //定义信号量标识抽烟是否完成
process P1(){                      //供应者while(1){random=任意一个整数随机数;random=random%3;if(random==0)V(offer1);             //提供烟草和纸else if(random==1)V(offer2);             //提供烟草和胶水elseV(offer3);             //提供纸和胶水任意两种材料放在桌子上;P(finish);}
}
process P2(){                      //拥有烟草者while(1){P(offer3);拿纸和胶水，卷成烟，抽掉;V(finish);}
}
process P3(){                      //拥有纸者while(1){P(offer2);拿烟草和胶水，卷成烟，抽掉;V(finish);}
}
process P4(){                      //拥有胶水者while(1){P(offer1);拿烟草和纸，卷成烟，抽掉;V(finish);}
}

（6）银行排队

王道P112

问题描述：
分析：
互斥资源：取号机设为mutex
同步问题：顾客需要空座位等待叫号，营业员空闲的时候将选取一位顾客为其服务。空位的有无影响顾客数量、顾客有无影响营业员开始服务，分别设置信号量empty和full实现同步。获得空位后，需要等待叫号和被服务，顾客与营业员就何时开始设置信号量service实现同步。

代码：

semaphore empty=10;       //空座位的数量，初值为10
semaphore mutex=1;        //互斥使用取号机
semaphore full=0;         //已占座位的数量，初值0
semaphore service=0;      //等待叫号
cobegin
{Process 顾客 i{P(empty);         //等待空位P(mutex);         //申请使用取号机从取号机上取号;V(mutex);         //区号完毕V(full);          //通知营业员有新顾客P(service);       //等待营业员叫号接受服务;}Process 营业员;{while(True){P(full);      //没有顾客则休息V(empty);     //离开座位V(service);   //叫号为顾客服务;}}
}coend

（7）理发师问题

王道P115#17，更复杂一点的见教材解答P50嗜睡的理发师

问题描述：
分析：
①控制变量waiting用来记录等候理发的顾客数，初值为0，进来一个顾客时，waiting 加1，一个顾客理发时，waiting 减1。
②信号量customers用来记录等候理发的顾客数，并用作阻塞理发师进程，初值为0。
③信号量barbers用来记录正在等候顾客的理发师数，并用作阻塞顾客进程，初值为0。
④信号量mutex用于互斥，初值为1。

代码

int waiting=0;            //等待理发的顾客数
int chairs=n;             //为顾客准备的椅子数
semaphore customers=0, barbers=0, mutex=1;
barber(){                 //理发师进程while(1){             //理完一人，还有顾客吗？P(customers);     //若无顾客，理发师睡眠P(mutex);         //进程互斥waiting=waiting-1;//等待顾客数-1V(barbers);       //理发师去为一个顾客理发V(mutex);         //开放临界区Cut_hair();       //正在理发}
}
customer(){               //顾客进程P(mutex);             //进程互斥if(waiting<chairs){   //若有空的椅子，就找到椅子坐下等待waiting=waiting+1;//等待顾客数+1V(customers);     //唤醒理发师V(mutex);         //开放临界区P(barbers);       //无理发师，顾客坐着get_haircut();    //一个顾客坐下等待理发}elseV(mutex);         //人满，离开       }
}

（8）驾驶员-售票员

王道P118#21

问题描述
分析：
驾驶员与售票员的同步关系：驾驶员启动车辆动作与售票员关车门动作同步；售票员开车门与驾驶员停车同步。设置两个信号量S1，S2。S1表示是否允许驾驶员启动汽车，S2表示是否允许售票员开门。

代码

semaphore S1=S2=0;
Procedure driver{while(1){P(S1);start;driving;stop;V(S2);}
}
Procedure Conductor{while(1){关车门;V(S1);售票;P(S2);开车门;上下乘客;}
}

四、死锁

简答、选填，考过多次

1、死锁的概念

死锁：多个进程因竞争资源而造成的一种僵局（互相等待），若无外力作用，这些进程都将无法向前推进。
死锁产生的原因：（考过）
1. 系统资源的竞争：对不可剥夺资源、可消耗资源的竞争。
2. 进程推进顺序非法：请求和释放资源的顺序不当、信号量使用不当。
3. 死锁产生的必要条件（考多次）同时满足：
  ①互斥条件：进程要求分配的资源是排他性的
  ②不剥夺条件：进程使用完资源之前，不能被强制夺走
  ③请求并保持条件：进程占有本身拥有的资源并要求其他资源。
  ④循环等待条件：存在一种进程资源的循环等待链。
  示例：循环等待不充分：

2、死锁的处理策略

※

处理策略
①死锁预防：设置限制条件、破坏必要条件。
②避免死锁：动态分配过程中阻止系统进入不安全状态。
③死锁的检测及解除
比较

3、死锁预防

双向推理，预防/避免/检测→有哪些；破坏互斥/银行家→属于哪类

破坏四个必要条件
- 破坏互斥条件：不太可行
- 破坏不剥夺条件：释放已获得的资源，常用于易于保存和恢复的资源，如CPU寄存器及内存资源。
- 破坏请求并保持条件：采用预先分配方法，进程在运行前一次申请完它所需要的全部资源。缺点：浪费、饥饿。
- 破坏循环等待条件：顺序资源分配法，同类资源一次申请完。缺点：限制新类型设备的增加、资源顺序与系统规定顺序不同。

4、死锁避免

（1）系统安全状态

安全状态：系统能按某种进程推进顺序为每个进程分配其所需的资源，直到满足每个进程对资源的最大雪球，使每个进程都可顺序完成。则该推进顺序为安全序列，无法找到时则为不安全状态。
不安全状态可能进入死锁状态，但安全状态便可避免死锁。

（2）银行家算法

简答，画矩阵分配图

思想：操作系统=银行家，操作系统管理的资源=银行家管理的资金，请求分配=贷款。进程运行前先声明对资源的最大需求量，测试已占+申请之和是否超过声明量，否则推迟分配。
数据结构描述：
①最大需求矩阵Max：nxm，n个进程中每个进程对m类资源的最大需求。
②分配矩阵Allocation：nxm，每类资源已经分配给每个进程的资源数。
③需求矩阵Need：nxm，每个进程接下来最多需要多少资源。
Need=Max−AllocationNeed=Max-AllocationNeed=Max−Allocation
银行家算法描述
①if request<need
②if request<available
③分配并修改数值
Available=Avaliable−requesti;Available=Avaliable-request_i;Available=Avaliable−requesti;
Allocation[i,j]=Allocation[i,j]+Requesti[j];Allocation[i,j]=Allocation[i,j]+Request_i[j];Allocation[i,j]=Allocation[i,j]+Requesti[j];
Need[i,j]=Need[i,j]−Requesti[j];Need[i,j]=Need[i,j]-Request_i[j];Need[i,j]=Need[i,j]−Requesti[j];
④执行安全性算法，否则分配作废。
安全性算法
①安全序列为空。work=available。
②找need<work，且不在安全序列的进程，加入安全序列。否则执行④。
③执行并释放资源，Work=Work+Allocation[i]Work=Work+Allocation[i]Work=Work+Allocation[i]，返回②。
④已处于安全状态。

（3）安全性算法举例

五个进程和三类资源，数量分别为10,5,7。T0T_0T0时刻的资源分配表。
max-allocation=need
找出need<work的行（work=available）。
(3,3,2)>(1,2,2)(3,3,2)>(1,2,2)(3,3,2)>(1,2,2)
(3,3,2)>(0,1,1)(3,3,2)>(0,1,1)(3,3,2)>(0,1,1)
对应进程分别为P1P_1P1和P3P_3P3，选择P1P_1P1加入安全序列。
释放P1P_1P1所占资源，allocation+work=work。
(2,0,0)+(3,2,2)=(5,3,2)=work(2,0,0)+(3,2,2)=(5,3,2)=work(2,0,0)+(3,2,2)=(5,3,2)=work
矩阵更新（去掉P1P_1P1），继续重复步骤3，最后得到一个安全序列。

（4）银行家算法举例

T0时刻的资源分配表，同上。
找到T0时刻的安全序列，同上。
P1P_1P1请求资源Request1(1,0,2)Request_1(1,0,2)Request1(1,0,2)，检查：
Request1(1,0,2)≤Need1(1,2,2)Request_1(1,0,2)≤Need_1(1,2,2)Request1(1,0,2)≤Need1(1,2,2)
Request1(1,0,2)≤Available1(3,3,2)Request_1(1,0,2)≤Available_1(3,3,2)Request1(1,0,2)≤Available1(3,3,2)
先假定可为P1P_1P1分配资源，并修改：
Available=Available−Request1=(2,3,0)Available=Available -Request_1=(2,3,0)Available=Available−Request1=(2,3,0)
Allocation1=Allocation1+Request1=(3,0,2)Allocation_1 = Allocation_1+Request_1=(3,0,2)Allocation1=Allocation1+Request1=(3,0,2)
Need1=Need1−Request1=(0,2,0)Need_1=Need_1-Request_1=(0,2,0)Need1=Need1−Request1=(0,2,0)
P1变化如表内圆括号的修改：
令work=available=(2,3,0)work=available=(2,3,0)work=available=(2,3,0)，再进行P1申请资源时的安全性检查
找到一个安全序列P1,P3,P4,P2,P0{P_1,P_3,P_4,P_2,P_0}P1,P3,P4,P2,P0，因此系统安全，为P1分配资源后的有关资源如表
P4请求资源：Request4(3,3,0)Request_4(3,3,0)Request4(3,3,0)
Request4(3,3,0)≤Need4(4,3,1);Request_4(3,3,0)≤Need_4(4,3,1);Request4(3,3,0)≤Need4(4,3,1);
Request4(3,3,0)＞Available(2,3,0);Request_4(3,3,0)＞Available(2,3,0);Request4(3,3,0)＞Available(2,3,0);
让P4等待。
P0请求资源：Request0(0,2,0)Request_0(0,2,0)Request0(0,2,0)
Request0(0,2,0)≤Need0(7,4,3);Request_0(0,2,0)≤Need_0(7,4,3);Request0(0,2,0)≤Need0(7,4,3);
Request0(0,2,0)≤Available0(2,3,0);Request_0(0,2,0)≤Available_0(2,3,0);Request0(0,2,0)≤Available0(2,3,0);
假定可分配，修改相关数据
Available=Available−Request0=(2,1,0)Available=Available -Request_0=(2,1,0)Available=Available−Request0=(2,1,0)
Allocation0=Allocation0+Request0=(0,3,0)Allocation_0 = Allocation_0+Request_0=(0,3,0)Allocation0=Allocation0+Request0=(0,3,0)
Need0=Need0−Request0=(7,2,3)Need_0=Need_0-Request_0=(7,2,3)Need0=Need0−Request0=(7,2,3)
为P0分配资源后的有关数据如表
进行安全性检查，可用资源Avaliable(2,1,0)Avaliable(2,1,0)Avaliable(2,1,0)不能满足任何进程的需要，进入不安全状态，拒绝P0，让P0等待，并将A柏拉不了、Allocation0、Need0恢复为之前的值。

5、死锁检测和解除

资源分配图（会画）：
圆圈：进程，框：资源，进程→资源：请求边，资源→进程：分配边。
简化资源分配图
①找出既不阻塞也不顾里的进程Pi（一条有向边相连，且该边对应资源的申请数量小于等于空闲资源，空闲资源=资源数-出度）。eg.P1
②进程Pi释放的资源可以唤醒某些因等待这些资源而阻塞的进程。
③重复①，若能消去图中所有边，则图可完全简化。
死锁定理：S为死锁的条件是当且仅当S状态的资源分配图是不可完全简化的。
死锁解除（优缺点）
①资源剥夺法。挂起某些死锁进程并抢占它的资源，分配给其他死锁进程。防止被挂起进程资源匮乏。
②撤销进程法。强制撤销部分甚至全部进程并剥夺资源。
③进程回退法。让一个或多个进程回退到足以回避死锁的地步

820操作系统（2）进程管理相关推荐

【操作系统】进程管理（二）
[操作系统]进程管理(二) 一.前言二.进程的基本概念 2.1 程序的顺序执行 2.2 程序的并发执行 2.3 进程的特征 2.4 进程的状态 2.5 进程控制块三.进程控制 3.1 进程的创建 ...
操作系统之——进程管理：同步进程和进程互斥
操作系统进程管理-同步和互斥在看了操作系统关于进程管理中的同步互斥机制章节之后,甚是困惑,今天通过视频.网上博客资料学习之后,整理一下相关知识点. 进程管理一.进程互斥由于进程具有独立性和异步性 ...
【操作系统】进程管理（五）—— 信号量机制
[操作系统]进程管理(五)-- 信号量机制前言一.信号量机制信号量机制--整型信号量信号量机制--记录型信号量二.用信号量机制实现进程互斥.同步.前驱关系信号量机制实现进程互斥信号量机制 ...
操作系统之进程管理-翟一鸣-专题视频课程
操作系统之进程管理-192人已学习课程介绍主要内容是程序的并发执行及进程的概念,进程的状态及其转换,进程的同步与互斥,进程通信与调度,进程死锁的概念及解决死锁的方法,线程的概念及其 ...
视频教程-操作系统之进程管理-操作系统
操作系统之进程管理 1979年出生于甘肃省兰州市,2001年7月本科毕业于西北师范大学计算机科学与技术专业,同年于烟台大学计算机学院任教至今:期间于2006年获得上海交通大学软件工程硕士学位,现为学院 ...
操作系统笔记——进程管理
操作系统笔记--进程管理 2. 进程管理 2.1 进程与线程 2.1.1 进程的引入前趋图程序的顺序执行程序的并发执行 2.1.2 进程的定义及描述进程的定义进程的特征进程和程序的关系进 ...
操作系统02进程管理Process_Description_and_Control
作业的基本概念:用户再一次计算过程中或一次事务处理过程中,要求计算机系统所做的工作的集合. 包含多个程序.多个数据.作业控制说明书系统调用时操作系统提供给编程人员的唯一接口. 1.文件操作类: 2. ...
操作系统之进程管理：3、进程控制(进程状态转化的实现)、原语、进程通信(共享、管道、消息)
3.进程控制进程控制思维导图进程控制相关的原语创建原语撤销原语阻塞原语.唤醒原语切换原语原语要做的几件事进程通信思维导图进程通信方式数据共享管道通信消息传递进程控制 1. ...
操作系统之进程管理相关总结
第三章进程管理 1.1进程的概念 1.1.1为什么要引入进程程序并发执行具有如下特征间断性失去封闭性不可再现性程序的并发可以总结为:一组在逻辑上相互独立的程序或程序段在执行过程中,其执行时 ...
操作系统基本原理---进程管理
处理机:计算机系统中存储程序和数据,并按照程序规定的步骤执行指令的部件.程序是描述处理机完成某项任务的指令序列.指令则是处理机能直接解释.执行的信息单位.处理机包括中央处理器,主存储器,输入-输出接口 ...

820操作系统（2）进程管理

操作系统——2.进程管理

考纲

一、进程与线程

1、进程的概念和特征

2、进程的状态和转换

3、进程控制

4、进程的组织/结构

5、进程的(高级)通信

6、线程概念和多线程模型

二、处理机调度

1、调度的概念

2、调度的时机、切换和过程

3、进程调度方式（考过）

4、调度的基本准则

5、调度算法

6、必考最后一题算法

三、进程同步

1、基本概念

2、实现临界区互斥的基本方法。

3、信号量/PV操作

4、信号量应用

5、管程

6、经典同步问题

（1）生产者-消费者问题1

（2）生产者-消费者问题2

（3）读者-写者问题

（4）哲学家进餐问题

（5）吸烟者问题

（6）银行排队

（7）理发师问题

（8）驾驶员-售票员

四、死锁

1、死锁的概念

2、死锁的处理策略

3、死锁预防

4、死锁避免

（1）系统安全状态

（2）银行家算法

（3）安全性算法举例

（4）银行家算法举例

5、死锁检测和解除

820操作系统（2）进程管理相关推荐

最新文章

热门文章