【操作系统】第2章 进程与线程

这是本人根据王道考研操作系统课程整理的笔记，希望对您有帮助。

第2章 进程与线程

2.1 进程与线程

2.1.1 进程的定义、组成、组织方式、特征

进程的定义

程序：就是一个指令序列

早期的计算机（只支持单道程序）：

引入多道程序技术之后：

为了方便操作系统管理，完成各程序并发执行，引入了进程、进程实体的概念。

PCB、程序段、数据段三部分构成了进程实体（进程映像）

一般情况下，我们把进程实体就简称为进程。例如，所谓创建进程，实质上是创建进程实体中的PCB；撤销进程，实质上是撤销进程实体中的PCB。

进程是进程实体的运行过程，是系统进行资源分配和调度的一个独立单位

严格来说，进程实体和进程并不一样。进程实体是静态的，进程则是动态的。

进程的组成

进程（进程实体）由程序段（存放要执行的代码）、数据段（存放程序运行过程中处理的各种数据）、PCB三部分组成

PCB的组成

• 进程描述信息

  • 进程标识符PID

    当进程被创建时，操作系统会为该进程分配一个唯一的、不重复的ID，用于区分不同的进程（类似于身份证号）

  • 用户标识符UID

    用于标识该进程被哪个用户所使用

• 进程控制和管理信息

  • 进程当前状态
  • 进程优先级

• 资源分配清单

  • 程序段指针
  • 数据段指针
  • 键盘
  • 鼠标

• 处理机相关信息

  • 各种寄存器值

    当进程切换时需要把进程当前的运行情况记录下来保存在PCB中，如程序计数器的值表示了当前程序执行到哪一句。

进程的组织

在一个系统中，通常有数十、数百乃至数千个PCB。为了能对他们加以有效的管理，应该用适当的方式把这些PCB组织起来。

链接方式

• 按照进程状态将PCB分为多个队列
• 操作系统持有指向各个队列的指针
  

索引方式

• 根据进程状态的不同，建立几张索引表
• 操作系统持有指向各个索引表的指针
  

进程的特征

• 动态性：进程是程序的一次执行过程，是动态地产生、变化和消亡的

  动态性是进程最基本的特性

• 并发性：内存中有多个进程实体，各进程可并发执行

• 独立性：进程是能独立运行、独立获得资源、独立接受调度的基本单位

• 异步性：各进程按各自独立的、不可预知的速度向前推进，操作系统要提供“进程同步机制”来解决异步问题

  异步性会导致并发程序执行结果的不确定性

• 结构性：每个进程都会配置一个PCB。结构上看，进程由程序段、数据段、PCB组成

2.1.2 进程的状态与转换

进程的状态

进程的三种基本状态

• 运行态（Running）：占有CPU，并在CPU上运行

  单核处理机环境下，每一时刻最多只有一个进程处于运行态

  双核处理机环境下，每一时刻可以有两个进程处于运行态

• 就绪态（Ready）：已经具备运行条件，但由于没有空闲CPU，而暂时不能运行

  进程己经拥有了除处理机之外所有需要的资源，一旦获得处理机，即可立即进入运行态开始运行

  即：万事俱备，只欠CPU

• 阻塞态（Waiting/Blocked，又称：等待态）：因等待某一事件而暂时不能运行

  如：等待操作系统分配打印机、等待读磁盘操作的结果。CPU是计算机中最昂贵的部件，为了提高CPU的利用率，需要先将其他进程需要的资源分配到位，才能得到CPU的服务

进程的另外两种状态

• 创建态（New，又称：新建态）：进程正在被创建，操作系统为进程分配资源、初始化PCB
• 终止态（Terminated，又称：结束态）：进程正在从系统中撤销，操作系统会回收进程拥有的资源、撤销PCB

进程状态的转换

2.1.3 进程控制

进程控制的主要功能是对系统中的所有进程实施有效的管理，它具有创建新进程、撤销已有进程、实现进程状态转换等功能。

简化理解：进程控制就是要实现进程状态转换

用原语实现进程控制。原语的特点是执行期间不允许中断，只能一气呵成。这种不可被关断的操作即原子操作

原语采用“关中断指令”和“开中断指令”实现（开/关中断指令的权限非常大，是只允许在核心态下执行的特权指令）

2.1.4 进程通信

为了保证安全，一个进程不能直接访问另一个进程的地址安全

共享存储

两个进程对共享空间的访问必须是互斥的（互斥访问通过操作系统提供的工具实现)

操作系统只负责提供共享空间和同步互斥工具（如P、V操作）

• 基于数据结构的共享：比如共享空间里只能放一个长度为10的数组。这种共享方式速度慢、限制多，是一种低级通信方式
• 基于存储区的共享：在内存中划出一块共享存储区，数据的形式、存放位置都由进程控制，而不是操作系统。相比之下，这种共享方式速度更快，是一种高级通信方式

管道通信

1. 管道只能采用半双工通信，某一时间段内只能实现单向的传输。如果要实现双向同时通信，则需要设置两个管道。
2. 各进程要互斥地访问管道。
3. 数据以字符流的形式写入管道，当管道写满时，写进程的write()系统调用将被阻塞，等待读进程将数据取走。当读进程将数据全部取走后，管道变空，此时读进程的read()系统调用将被阻塞。
4. 如果没写满，就不允许读。如果没读空，就不允许写。
5. 数据一旦被读出，就从管道中被抛弃，这就意味着读进程最多只能有一个，否则可能会有读错数据的情况。

消息传递

进程间的数据交换以格式化的消息(Message)为单位。进程通过操作系统提供的“发送消息/接收消息”两个原语进行数据交换。

• 直接通信方式：消息直接挂到接收进程的消息缓冲队列上
  

• 间接通信方式：消息要先发送到中间实体（信箱）中，因此也称“信箱通信方式”
  

2.1.5 线程概念和多线程模型

线程是一个基本的CPU执行单元，也是程序执行流的最小单位。

引入线程之后，不仅是进程之间可以并发，进程内的各线程之间也可以并发，从而进一步提升了系统的并发度，使得一个进程内也可以并发处理各种任务（如QQ视频、文字聊天、传文件）

引入线程后，进程只作为除CPU之外的系统资源的分配单元（如打印机、内存地址空间等都是分配给进程的)。

引入线程机制带来的变化

• 资源分配、调度
  • 传统进程机制中，进程是资源分配、调度的基本单位
  • 引入线程后，进程是资源分配的基本单位，线程是调度的基本单位
• 并发性
  • 传统进程机制中，只能进程间并发
  • 引入线程后，各线程间也能并发，提升了并发度
• 系统开销
  • 传统的进程间并发，需要切换进程的运行环境，系统开销很大
  • 线程间并发，如果是同一进程内的线程切换，则不需要切换进程环境，系统开销小
  • 引入线程后，并发所带来的系统开销减小

线程的实现方式

用户级线程（User-Level Thread, ULT）

• 用户级线程由应用程序通过线程库实现
• 所有的线程管理工作都由应用程序负责（包括线程切换）
• 用户级线程中，线程切换可以在用户态下即可完成，无需操作系统干预
• 在用户看来，是有多个线程。但是在操作系统内核看来，并意识不到线程的存在。（用户级线程对用户不透明，对操作系统透明）
• 可以这样理解，“用户级线程”就是“从用户视角能看到的线程”

---

内核级线程（Kernel-Level Thread, KLT, 又称“内核支持的线程”）

• 内核级线程的管理工作由操作系统内核完成。线程调度、切换等工作都由内核负责，因此内核级线程的切换必然需要在核心态下才能完成。
• 可以这样理解，**“内核级线程”**就是“从操作系统内核视角看能看到的线程”
• 操作系统只“看得见”内核级线程，因此只有内核级线程才是处理机分配的单位。

多线程模型

多对一模型：多个用户级线程映射到一个内核级线程。每个用户进程只对应一个内核级线程

• 优点：用户级线程的切换在用户空间即可完成，不需要切换到核心态，线程管理的系统开销小，效率高
• 缺点：当一个用户级线程被阻塞后，整个进程都会被阻塞，并发度不高。多个线程不可在多核处理机上并行运行

---

一对一模型：一个用户及线程映射到一个内核级线程。每个用户进程有与用户级线程同数量的内核级线程。

• 优点：当一个线程被阻塞后，别的线程还可以继续执行，并发能力强。多线程可在多核处理机上并行执行。
• 缺点：一个用户进程会占用多个内核级线程，线程切换由操作系统内核完成，需要切换到核心态，因此线程管理的成本高，开销大。

---

多对多模型：$n$个用户级线程映射到$m$个内核级线程$(n>=m)$。每个用户进程对应$m$个内核级线程。

克服了多对一模型并发度不高的缺点，又克服了一对一模型中一个用户进程占用太多内核级线程，开销太大的缺点。

2.2 处理机调度

2.2.1 处理机调度的概念、层次

在多道程序系统中，进程的数量往往是多于处理机的个数的，这样不可能同时并行地处理各个进程。

处理机调度，就是从就绪队列中按照一定的算法选择一个进程并将处理机分配给它运行，以实现进程的并发执行。

调度的三个层次——高级调度

由于内存空间有限，有时无法将用户提交的作业全部放入内存，因此就需要确定某种规则来决定将作业调入内存的顺序。

高级调度（作业调度）。按一定的原则从外存上处于后备队列的作业中挑选一个（或多个）作业，给他们分配内存等必要资源，并建立相应的进程（建立PCB），以使它（们）获得竞争处理机的权利。

高级调度是辅存（外存）与内存之间的调度。每个作业只调入一次，调出一次。作业调入时会建立相应的PCB，作业调出时才撤销PCB。高级调度主要是指调入的问题，因为只有调入的时机需要操作系统来确定，但调出的时机必然是作业运行结束才调出。

调度的三个层次——中级调度

引入了虚拟存储技术之后，可将暂时不能运行的进程调至外存等待。等它重新具备了运行条件且内存又稍有空闲时，再重新调入内存。

这么做的目的是为了提高内存利用率和系统吞吐量。

暂时调到外存等待的进程状态为挂起状态。值得注意的是，PCB并不会一起调到外存，而是会常驻内存。PCB中会记录进程数据在外存中的存放位置，进程状态等信息，操作系统通过内存中的PCB来保持对各个进程的监控、管理。被挂起的进程PCB会被放到的挂起队列中。

中级调度（内存调度），就是要决定将哪个处于挂起状态的进程重新调入内存。

一个进程可能会被多次调出、调入内存，因此中级调度发生的频率要比高级调度更高。

进程的挂起态与七状态模型

暂时调到外存等待的进程状态为挂起状态（挂起态，suspend）

挂起态又可以进一步细分为就绪挂起、阻塞挂起两种状态

调度的三个层次——低级调度

低级调度（进程调度），其主要任务是按照某种方法和策略从就绪队列中选取一个进程，将处理机分配给它。

进程调度是操作系统中最基本的一种调度，在一般的操作系统中都必须配置进程调度。

进程调度的频率很高，一般几十毫秒一次。

三层调度的联系、对比

2.2.2 进程调度的时机、切换与过程、方式

进程调度的时机

需要进行进程调度与切换的情况

• 当前运行的进程主动放弃处理机
  • 进程正常终止
  • 运行过程中发生异常而终止
  • 进程主动请求阻塞（如：等待I/O）
• 当前运行的进程被动放弃处理机
  • 分给进程的时间片用完
  • 有更紧急的事需要处理（如I/O中断）
  • 有更高优先级的进程进入就绪队列

不能进行进程调度与切换的情况

• 在处理中断的过程中。中断处理过程复杂，与硬件密切相关，很难做到在中断处理过程中进行进程切换。

• 进程在操作系统内核程序临界区中。

  临界资源：一个时间段内只允许一个进程使用的资源。各进程需要互斥地访问临界资源。

  临界区：访问临界资源的那段代码。

  内核程序临界区一般是用来访问某种内核数据结构的，比如进程的就绪队列（由各就绪进程的PCB组成）

• 在原子操作过程中（原语）。原子操作不可中断，要一气呵成（如之前讲过的修改PCB中进程状态标志，并把PCB放到相应队列）

进程调度的方式

非剥夺调度方式，又称非抢占方式。即，只允许进程主动放弃处理机。在运行过程中即便有更紧迫的任务到达，当前进程依然会继续使用处理机，直到该进程终止或主动要求进入阻塞态。

实现简单，系统开销小但是无法及时处理紧急任务，适合于早期的批处理系统

剥夺调度方式，又称抢占方式。当一个进程正在处理机上执行时，如果有一个更重要或更紧迫的进程需要使用处理机，则立即暂停正在执行的进程，将处理机分配给更重要紧迫的那个进程。

可以优先处理更紧急的进程，也可实现让各进程按时间片轮流执行的功能（通过时钟中断）。适合于分时操作系统、实时操作系统。

进程的切换与过程

狭义的进程调度指的是从就绪队列中选中一个要运行的进程。（这个进程可以是刚刚被暂停执行的进程，也可能是另一个进程，后一种情况就需要进程切换）

进程切换是指一个进程让出处理机，由另一个进程占用处理机的过程。

广义的进程调度包含了选择一个进程和进程切换两个步骤。

注意：进程切换是有代价的，因此如果过于频繁的进行进程调度、切换，必然会使整个系统的效率降低，使系统大部分时间都花在了进程切换上，而真正用于执行进程的时间减少。

2.2.3 调度算法的评价指标

CPU利用率：CPU“忙碌”的事件占总时间的比例

系统吞吐量：单位时间内完成作业的数量

周转时间：作业被提交给系统开始，到作业完成为止的这段时间间隔

带权周转时间：作业周转时间 / 作业实际运行的时间

平均带权周转时间：各作业带权周转时间之和 / 作业数

等待时间：进程/作业处于等待处理机状态时间之和，等待时间越长，用户满意度越低

响应时间：用户提交请求到首次响应所用的时间

2.2.4 FCFS、SJF、HRRN调度算法

饥饿：某进程/作业长期得不到服务

应用：这三种算法一般适合于早期的批处理系统

2.2.5 调度算法：时间片轮转、优先级、多级反馈队列

应用：适合于分时操作系统

应用：适合于实时操作系统

应用：平衡优秀666

总结：这三种算法适合用于交互式系统（包括分时操作系统、实时操作系统等）

2.3 同步与互斥

2.3.1 进程同步、进程互斥

进程同步

同步亦称直接制约关系，它是指为完成某种任务而建立的两个或多个进程，这些进程因为需要在某些位置上协调它们的工作次序而产生的制约关系。进程间的直接制约关系就是源于它们之间的相互合作。

进程互斥

我们把一个时间段内只允许一个进程使用的资源称为临界资源。许多物理设备（比如摄像头、打印机）都属于临界资源。此外还有许多变量、数据、内存缓冲区等都属于临界资源。

对临界资源的访问，必须互斥地进行。互斥，亦称间接制约关系。进程互斥指当一个进程访问某临界资源时，另一个想要访问该临界资源的进程必须等待。当前访问临界资源的进程访问结束，释放该资源之后，另一个进程才能去访问临界资源。

四个部分

• 进入区：检查是否可进入临界区，若可进入，需要“上锁”
• 临界区：访问临界资源的那段代码
• 退出区：负责“解锁”
• 剩余区：其余代码部分

do {
    entry section;		//进入区
    critical section;	//临界区
    exit section;		//退出区
    remainder section;	//剩余区
}
1
2
3
4
5
6

需要遵循的原则

• 空闲让进：临界区空闲时，应允许一个进程访问

  厕所空了就进人

• 忙则等待：临界区正在被访问，其他试图访问的进程需要等待

  厕所里有人就要等着

• 有限等待：要在有限的时间内进入临界区，保证不会饥饿

  确保你一定能上得到厕所

• 让权等待：进不了临界区的进程，要释放处理机，防止忙等

  如果拉不出来赶紧出去让别人上

2.3.2 进程互斥的软件实现方法

单标志法

算法思想：两个进程在访问完临界区后会把使用临界区的权限转交给另一个进程。也就是说每个进程进入临界区的权限只能被另一个进程赋予

该算法可以实现同一时刻最多只允许一个进程访问临界区

问题：违背 空闲让进 原则

双标志先检查法

算法思想：设置一个布尔型数组flag[],数组中各个元素用来标记各进程想进入临界区的意愿，比如flag[0]=true意味着0号进程P0现在想要进入临界区。每个进程在进入临界区之前先检查当前有没有别的进程想进入临界区，如果没有，则把自身对应的标志flag[i]设为true,之后开始访问临界区。

问题：违反 忙则等待 原则

问题来源：进入区的“检查”、“上锁”操作无法一气呵成

双标志后检查法

算法思想：双标志先检查法的改版。前一个算法的问题是先“检查”后“上锁”，但是这两个操作又无法一气呵成，因此导致了两个进程同时进入临界区的问题。因此，人们又想到**先“上锁”后“检查”**的方法，来避免上述问题。

问题：违反 空闲让进 和 有限等待 原则

Peterson算法

算法思想：双标志后检查法中，两个进程都争着想进入临界区，但是谁也不让准，最后谁都无法进入临界区。Gary L. Peterson想到了一种方法，如果双方都争着想进入临界区，那可以让进程尝试“孔融让梨”，主动让对方先使用临界区。

问题：违反 让权等待 原则

2.3.3 进程互斥的硬件实现方法

中断屏蔽方法

利用“开/关中断指令”实现（与原语的实现思想相同，即在某进程开始访问临界区到结束访问为止都不允许被中断，也就不能发生进程切换，因此也不可能发生两个同时访问临界区的情况）

• 优点：简单、高效
• 缺点：不适用于多处理机：只适用于操作系统内核进程，不适用于用户进程（因为开/关中断指令只能运行在内核态，这组指令如果能让用户随意使用会很危险)

TestAndSet指令

简称TS指令，也有地方称为TestAndSetLock指令，或TSL指令。

TSL指令是用硬件实现的，执行的过程不允许被中断，只能一气呵成。

相比软件实现方法，TSL指令把“上锁”和“检查”操作用硬件的方式变成了一气呵成的原子操作。

• 优点：实现简单，无需像软件实现方法那样严格检查是否会有逻辑漏洞：适用于多处理机环境
• 缺点：不满足“让权等待”原则，暂时无法进入临界区的进程会占用CPU并循环执行TSL指令，从而导致“忙等”。

Swap指令

有的地方也叫Exchange指令，或简称XCHG指令。

Swap指令是用硬件实现的，执行的过程不允许被中断，只能一气呵成。

逻辑上来看Swap和TSL并无太大区别，都是先记录下此时临界区是否己经被上锁（记录在old变量上)，再将上锁标记lock设置为true,最后检查old，如果old为false则说明之前没有别的进程对临界区上锁，则可跳出循环，进入临界区。

• 优点：实现简单，无需像软件实现方法那样严格检查是否会有逻辑漏洞：适用于多处理机环境
• 缺点：不满足“让权等待”原则，暂时无法进入临界区的进程会占用CPU并循环执行TSL指令，从而导致“忙等”。

2.3.4 信号量机制

用户进程可以通过使用操作系统提供的一对原语来对信号量进行操作，从而很方便的实现了进程互斥、进程同步。

信号量其实就是一个变量（可以是一个整数，也可以是更复杂的记录型变量），可以用一个信号量来表示系统中某种资源的数量，比如：系统中只有一台打印机，就可以设置一个初值为1的信号量。

原语是一种特殊的程序段，其执行识能一气呵成，不可被中断。原语是由关中断/开中断指令实现的。软件解决方案的主要问题是由“进入区的各种操作无法一气呵成”，因此如果能把进入区、退出区的操作都用“原语”实现，使这些操作能“一气呵成”就能避免问题。

一对原语：wait(S)原语和signal(S)原语，可以把原语理解为我们自己写的函数，函数名分别为wait和signal，括号里的信号量S其实就是函数调用时传入的一个参数。

wait、signal原语常简称为P、V操作。因此，做题的时候常把wait(S)、signal(S)两个操作分别写为P(S)、V(S)

整型信号量

用一个整数型的变量作为信号量，用来表示系统中某种资源的数量

“检查”和“上锁”一气呵成，避免了并发、异步导致的问题

存在的问题：不满足“让权等待”原则，会发生“忙等”

记录型信号量

整型信号量的缺陷是存在“忙等”问题，因此人们又提出了“记录型信号量”，即用记录型数据结构表示的信号量。

该机制遵循了“让权等待”原则，不会出现“忙等”现象。

2.3.5 用信号量机制实现进程互斥、同步、前驱关系

信号量机制实现进程互斥

1. 分析并发进程的关键活动，划定临界区（如：对临界资源打印机的访问就应放在临界区）
2. 设置互斥信号量mutex，初值为1
3. 在临界区之前执行P(mutex)
4. 在临界区之后执行V(mutex)
   

注意：

• 对不同的临界资源需要设置不同的互斥信号量
  

• P、V操作必须成对出现。缺少P(mutex)就不能保证临界资源的互斥访问。缺少V(mutex)会导致资源永不被释放，等待进程永不被唤醒

信号量机制实现进程同步

进程同步：要让各并发进程按要求有序地推进

1. 分析什么地方需要实现“同步关系”，即必须保证“一前一后”执行的两个操作（或两句代码）
2. 设置同步信号量S，初始为0
3. 在“前操作”之后执行V(S)
4. 在“后操作”之前执行P(S)
   

以上代码保证了代码4一定是在代码2之后执行。

信号量机制实现前驱关系

每一对前驱关系都是一个进程同步问题（需要保证一前一后的操作)

1. 要为每一对前驱关系各设置一个同步变量
2. 在“前操作”之后对相应的同步变量执行V操作
3. 在“后操作”之前对相应的同步变量执行P操作
   
   

2.3.6 生产者-消费者问题

问题描述

系统中有一组生产者进程和一组消费者进程，生产者进程每次生产一个产品放入缓冲区，消费者进程每次从缓冲区中取出一个产品并使用。（注：这里的“产品”理解为某种数据）

生产者、消费者共享一个初始为空、大小为n的缓冲区。

只有缓冲区没满时，生产者才能把产品放入缓冲区，否则必须等待。

只有缓冲区不空时，消费者才能从中取出产品，否则必须等待。

缓冲区是临界资源，各进程必须互斥地访问。

实现

2.3.7 多生产者-多消费者问题

问题描述

分析

互斥关系（mutex=1）

• 对缓冲区（盘子）的访问要互斥地进行

同步关系（一前一后）

1. 父亲将苹果放入盘子后，女儿才能取苹果

2. 母亲将橘子放入盘子后，儿子才能取橘子

3. 只有盘子为空，父亲或母亲才能放入水果

   “盘子为空”这个事件可以由儿子或女儿触发，事件发生后才允许父亲或母亲放水果

实现

2.3.8 吸烟者问题

问题描述

假设一个系统有三个抽烟者进程和一个供应者进程。每个抽烟者不停地卷烟并抽掉它，但是要卷起并抽掉一支烟，抽烟者需要有三种材料：烟草、纸和胶水。三个抽烟者中，第一个拥有烟草、第二个拥有纸、第三个拥有胶水。供应者进程无限地提供三种材料，供应者每次将两种材料放桌子上，拥有剩下那种材料的抽烟者卷一根烟并抽掉它，并给供应者进程一个信号告诉完成了，供应者就会放另外两种材料再桌上，这个过程一直重复（让三个抽烟者轮流地抽烟）

分析

同步关系

• 桌上有组合一→第一个抽烟者取走东西

  组合一：纸+胶水

• 桌上有组合二→第二个抽烟者取走东西

  组合二：烟草+胶水

• 桌上有组合三→第三个抽烟者取走东西

  组合三：烟草+纸

• 发出完成信号→供应者将下一个组合放到桌上

PV操作顺序：前V后P

实现

2.3.9 读者-写者问题

问题描述

有读者和写者两组并发进程，共享一个文件，当两个或两个以上的读进程同时访问共享数据时不会产生副作用，但若某个写进程和其他进程（读进程或写进程）同时访问共享数据时则可能导致数据不一致的错误。

因此要求：

1. 允许多个读者可以同时对文件执行读操作；
2. 只允许一个写者往文件中写信息；
3. 任一写者在完成写操作之前不允许其他读者或写者工作；
4. 写者执行写操作前，应让已有的读者和写者全部退出。
   

分析

两类进程：写进程、读进程

互斥关系：写进程一写进程、写进程一读进程。读进程与读进程不存在互斥问题。

写者进程和任何进程都互斥，设置一个互斥信号量rw，在写者访问共享文件前后分别执行P、V操作。读者进程和写者进程也要互斥，因此读者访问共享文件前后也要对rw执行P、V操作。

实现

改进（读写公平法）：

2.3.10 哲学家进餐问题

问题描述

一张圆桌上坐着5名哲学家，每两个哲学家之间的桌上摆一根筷子，桌子的中间是一碗米饭。哲学家们倾注毕生的精力用于思考和进餐，哲学家在思考时，并不影响他人。只有当哲学家饥饿时，才试图拿起左、右两根筷子（一根一根地拿起）。如果筷子已在他人手上，则需等待。饥饿的哲学家只有同时拿起两根筷子才可以开始进餐，当进餐完毕后，放下筷子继续思考。

背景：每个进程都需要同时持有两个临界资源，因此就有“死锁”问题的隐患。

分析

这个问题中只有互斥关系，但与之前遇到的问题不同的事，每个哲学家进程需要同时持有两个临界资源才能开始吃饭。如何避免临界资源分配不当造成的死锁现象，是哲学家问题的精髓。

信号量设置：定义互斥信号量数组chopstick[5]={1,1,1,1,1}用于实现对5个筷子的互斥访问。并对哲学家按0~4编号，哲学家i左边的筷子编号为i，右边的筷子编号为(i+1)%5。

预防死锁的发生

1. 可以对哲学家进程施加一些限制条件，比如最多允许四个哲学家同时进餐。这样可以保证至少有一个哲学家是可以拿到左右两只筷子的。
2. 要求奇数号哲学家先拿左边的筷子，然后再拿右边的筷子，而偶数号哲学家刚好相反。用这种方法可以保证如果相邻的两个奇偶号哲学家都想吃饭，那么只会有其中一个可以拿起第一只筷子，另一个会直接阻塞。这就避免了占有一支后再等待另一只的情况。
3. 仅当一个哲学家左右两支筷子都可用时才允许他抓起筷子。
   • 更准确的说法是：各哲学家拿筷子这件事必须互斥的执行。这就保证了即使一个哲学家在拿筷子拿到一半时被阻塞，也不会有别的哲学家会继续尝试拿筷子。这样的话，当前正在吃饭的哲学家放下筷子后，被阻塞的哲学家就可以获得等待的筷子了。
   • 

2.3.11 管程

信号量机制存在的问题：编写程序困难、易出错

管程的定义

管程是一种特殊的软件模块，由这些部分组成：

1. 局部于管程的共享数据结构说明；

2. 对该数据结构进行操作的一组过程；

   “过程”其实就是“函数”

3. 对局部于管程的共享数据设置初始值的语句；

4. 管程有一个名字。

管程的基本特征

1. 局部于管程的数据只能被局部于管程的过程所访问；
2. 一个进程只有通过调用管程内的过程才能进入管程访问共享数据；
3. 每次仅允许一个进程在管程内执行某个内部过程。

用管程解决生产者-消费者问题

引入管程的目的：要更方便地实现进程互斥和同步

1. 需要在管程中定义共享数据（如生产者消费者问题的缓冲区）
2. 需要在管程中定义用于访问这些共享数据的“入口”一一其实就是一些函数（如生产者消费者问题中，可以定义一个函数用于将产品放入缓冲区，再定义一个函数用于从缓冲区取出产品）
3. 只有通过这些特定的“入口”才能访问共享数据
4. 管程中有很多“入口”，但是每次只能开放其中一个“入口”，并且只能让一个进程或线程进入（如生产者消费者问题中，各进程需要互斥地访问共享缓冲区。管程的这种特性即可保证一个时间段内最多只会有一个进程在访问缓冲区。注意：这种互斥特性是由编译器负责实现的，程序员不用关心）
5. 可在管程中设置条件变量及等待/唤醒操作以解决同步问题。可以让一个进程或线程在条件变量上等待（此时，该进程应先释放管程的使用权，也就是让出“入口”）；可以通过唤醒操作将等待在条件变量上的进程或线程唤醒。

2.4 死锁

2.4.1 死锁的概念

在并发环境下，各进程因竞争资源而造成的一种互相等待对方手里的资源，导致各进程都阻塞，都无法向前推进的现象，就是“死锁”。发生死锁后若无外力干涉，这些进程都将无法向前推进

死锁、饥饿、死循环的区别

死锁：各进程互相等待对方手里的资源，导致各进程都阻塞，无法向前推进的现象。

饥饿：由于长期得不到想要的资源，某进程无法向前推进的现象。比如：在短进程优先(SPF)算法中，若有源源不断的短进程到来，则长进程将一直得不到处理机，从而发生长进程“饥饿”。

死循环：某进程执行过程中一直跳不出某个循环的现象。有时是因为程序逻辑bug导致的，有时是程序员故意设计的。

---

• 共同点：都是进程无法顺利向前推进的现象（故意设计的死循环除外）
• 不同点
  • 死锁：死锁一定是“循环等待对方手里的资源”导致的，因此如果有死锁现象，那至少有两个或两个以上的进程同时发生死锁。另外，发生死锁的进程一定处于阻塞态。
  • 饥饿：可能只有一个进程发生饥饿。发生饥饿的进程既可能是阻塞态（如长期得不到需要的/O设备)，也可能是就绪态（长期得不到处理机）
  • 死循环：可能只有一个进程发生死循环。死循环的进程可以上处理机运行（可以是运行态)，只不过无法像期待的那样顺利推进。死锁和饥饿问题是由于操作系统分配资源的策略不合理导致的，而死循环是由代码逻辑的错误导致的。死锁和饥饿是管理者（操作系统）的问题，死循环是被管理者的问题。

死锁产生的必要条件

产生死锁必须同时满足以下四个条件，只要其中任一条件不成立，死锁就不会发生。

互斥条件：只有对必须互斥使用的资源的争抢才会导致死锁（如哲学家的筷子、打印机设备）像内存、扬声器这样可以同时让多个进程使用的资源是不会导致死锁的（因为进程不用阻塞等待这种资源)。

不剥夺条件：进程所获得的资源在未使用完之前，不能由其他进程强行夺走，只能主动释放。

请求和保持条件：进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源又被其他进程占有，此时请求进程被阻塞，但又对自己己有的资源保持不放。

循环等待条件：存在一种进程资源的循环等待链，链中的每一个进程己获得的资源同时被下一个进程所请求

注意：发生死锁时一定有循环等待，但是发生循环等待时未必死锁。（循环等待是死锁的必要不充分条件）

什么时候会发生死锁

1. 对系统资源的竞争。各进程对不可剥夺的资源（如打印机）的竞争可能引起死锁，对可剥夺的资源（CPU）的竞争是不会引起死锁的。
2. 进程推进顺序非法。请求和释放资源的顺序不当，也同样会导致死锁。例如，并发执行的进程P1、P2分别申请并占有了资源R1、R2，之后进程P1又紧接着申请资源R2，而进程P2又申请资源R1，两者会因为申请的资源被对方占有而阻塞，从而发生死锁。
3. 信号量的使用不当。如生产者-消费者问题中，如果实现互斥的P操作在实现同步的P操作之前，就有可能导致死锁。（可以把互斥信号量、同步信号量也看做是一种抽象的系统资源）

死锁的处理策略

1. 预防死锁。破坏死锁产生的四个必要条件中的一个或几个。
2. 避免死锁。用某种方法防止系统进入不安全状态，从而避免死锁（银行家算法）
3. 死锁的检测和解除。允许死锁的发生，不过操作系统会负责检测出死锁的发生，然后采取某种措施解除死锁。

2.4.2 死锁的处理策略——预防死锁

2.4.3 死锁的处理策略——避免死锁

什么是安全序列

所谓安全序列，就是指如果系统按照这种序列分配资源，则每个进程都能顺利完成。只要能找出一个安全序列，系统就是安全状态。当然，安全序列可能有多个。

如果分配了资源之后，系统中找不出任何一个安全序列，系统就进入了不安全状态。这就意味着之后可能所有进程都无法顺利的执行下去。当然，如果有进程提前归还了一些资源，那系统也有可能重新回到安全状态，不过我们在分配资源之前总是要考虑到最坏的情况。

如果系统处于安全状态，就一定不会发生死锁。如果系统进入不安全状态，就可能发生死锁（处于不安全状态未必就是发生了死锁，但发生死锁时一定是在不安全状态）

因此可以在资源分配之前预先判断这次分配是否会导致系统进入不安全状态以此决定是否答应资源分配请求。这也是“银行家算法”的核心思想。

银行家算法

核心思想：在进程提出资源申请时，先预判此次分配是否会导致系统进入不安全状态。如果会进入不安全状态，就暂时不答应这次请求，让该进程先阻塞等待。

问题：BAT的例子中，只有一种类型的资源一一钱，但是在计算机系统中会有多种多样的资源，应该怎么把算法拓展为多种资源的情况呢？

解答：可以把单维的数字拓展为多维的向量。

比如：系统中有5个进程P0-P4，3种资源R0-R2，初始数量为(10,5,7)

此时总共已分配(7,2,5)，还剩余(3,3,2)。可把最大需求、已分配的数据看作矩阵两矩阵相减，就可算出各进程最多还需要多少资源了。

算法步骤：

1. 检查此次申请是否超过了之前声明的最大需求数
2. 检查此时系统剩余的可用资源是否还能满足这次请求
3. 试探着分配，更改各数据结构
4. 用安全性算法检查此次分配是否会导致系统进入不安全状态

安全性算法步骤：

1. 检查当前的剩余可用资源是否能满足某个进程的最大需求，如果可以，就把该进程加入安全序列，并把该进程持有的资源全部回收。
2. 不断重复上述过程，看最终是否能让所有进程都加入安全序列。

2.4.4 死锁的处理策略——检测和解除

资源分配图

• 两种结点
  • 进程结点：对应一个进程
  • 资源结点：对应一类资源，一类资源可能有多个
• 两种边
  • 进程结点→资源结点：表示进程想申请几个资源（每条边代表一个）
  • 资源结点→进程结点：表示已经为进程分配了几个资源（每条边代表一个）
    

死锁的检测

如果系统中剩余的可用资源数足够满足进程的需求，那么这个进程暂时是不会阻塞的，可以顺利地执行下去。

如果这个进程执行结束了把资源归还系统，就可能使某些正在等待资源的进程被激活，并顺利地执行下去。

相应的，这些被激活的进程执行完了之后又会归还一些资源，这样可能又会激活另外一些阻塞的进程。

---

如果按上述过程分析，最终能消除所有边，就称这个图是可完全简化的。此时一定没有发生死锁（相当于能找到一个安全序列）

如果最终不能消除所有边，那么此时就是发生了死锁。

用死锁检测算法化简资源分配图后，最终还连着边的那些进程就是处于死锁状态的进程。

死锁的解除

1. 资源剥夺法 挂起（暂时放到外存上）某些死锁进程，并抢占它的资源，将这些资源分配给其他的死锁进程。但是应防止被挂起的进程长时间得不到资源而饥饿。
2. 撤销进程法（或称终止进程法） 强制撤销部分、甚至全部死锁进程，并剥夺这些进程的资源。这种方式的优点是实现简单，但所付出的代价可能会很大。因为有些进程可能已经运行了很长时间，己经接近结束了，一旦被终止可谓功亏一篑，以后还得从头再来。
3. 进程回退法 让一个或多个死锁进程回退到足以避免死锁的地步。这就要求系统要记录进程的历史信息，设置还原点。