408操作系统知识点——第二章进程与线程

豆奶特浓6

已于 2024-05-14 22:50:30 修改

阅读量813

点赞数 31

分类专栏： 408操作系统文章标签：考研学习

于 2024-05-14 22:49:09 首次发布

本文链接：https://blog.csdn.net/m0_61049985/article/details/138873644

版权

408操作系统专栏收录该内容

5 篇文章 0 订阅

订阅专栏

文章目录

进程与线程
处理机调度
同步与互斥
死锁

注：内容参考王道2024考研复习指导

进程与线程

进程的概念和特征

进程的概念

在多道程序环境下，允许多个程序并发执行，此时它们将失去封闭性，并具有间断性及不可再现性的特征。为此引入了进程（Process）的概念，以便更好地描述和控制程序的并发执行，实现操作系统的并发性和共享性(最基本的两个特性)。

注：程序的封闭性是指进程执行的结果只取决于进程本身，不受外界影响。失去封闭性后，不同速度下的执行结果不同。

为了每个程序（含数据）都能独立地运行，为之配置一个专门的数据结构，称为进程控制块（PCB）。系统利用PCB 来描述进程的基本情况和运行状态，进而控制和管理进程。

程序段、相关数据段和PCB三部分构成了进程实体（又称进程映像）。

所谓创建进程，就是创建进程的PCB；而撤销进程，就是撤销进程的PCB。

进程典型的定义有：

进程是一个正在执行程序的实例。
进程是一个程序及其数据从磁盘加载到内存后，在CPU上的执行过程。
进程是一个具有独立功能的程序在一个数据集合上运行的过程。

引入进程实体的概念后，可将进程定义为：进程是进程实体的运行过程，是系统进行资源分配和调度的一个独立单位。

注：系统资源。它指CPU、存储器和其他设备服务于某个进程的“时间”，如CPU资源为CPU的时间片。

注：一个进程可以顺序地执行一个或多个程序，只要执行过程中改变其CPU状态和内存空间即可，但不能同时执行多个程序。

进程的特征

进程是由多道程序的并发执行而引出的，它和程序是两个截然不同的概念。程序是静态的，进程是动态的。

动态性。进程是程序的一次执行过程，是动态地产生、变化和消亡的。动态性是进程最基本的特征。
并发性。内存中有多个进程实体，各进程可并发进行。
独立性。进程是能独立运行、独立获得资源、独立接受调度的基本单位。
异步性。各进程按各自独立的、不可预知的速度向前推进，操作系统要提供“进程同步机制”来解决异步问题。
结构性。每个进程都会配置一个PCB，从结构上看，进程由程序段、数据段、PCB组成。

注：只求理解。

进程的组成

进程是一个独立的运行单位，也是操作系统进行资源分配和调度的基本单位。它三部
分组成，其中最核心的是进程控制块（PCB）。

进程控制块（PCB）

PCB是进程存在的唯一标志，当进程被创建时，操作系统为其创建PCB，当进程结束时，会回收其PCB。

主要记录以下信息：

进程描述信息，包括进程标识符PID（唯一）和用户标识符UID。
进程控制和管理信息，包括CPU、磁盘、网络流量使用情况统计以及进程当前状态。
资源分配清单，包括正在使用哪些文件、正在使用哪些内存区域、正在使用哪些I/O设备。
处理机相关信息，也称CPU的上下文，包括PSW、PC等各种寄存器的值，用于实现进程切换。

程序段、数据段

程序段就是能被进程调度程序调度到CPU执行的程序代码段，即指令序列。

数据段包括运行过程中产生的各种数据，如程序中的原始数据、定义的变量、中间或最终结果。

注：

PCB是给操作系统用的。程序段、数据段是给进程自己用的。

程序可被多个进程共享，即多个进程可以运行同一个程序。

一个进程被“调度”，就是指操作系统决定让这个进程上CPU运行。

进程的状态与切换

进程的状态

进程在其生命周期内，由于系统中各个进程之间的相互制约及系统的运行环境的变化，使得进程的状态也在不断地发生变化（也即进程的生命周期不是连续的）。通常进程有以下5种状态，中间3种是进程的基本状态：

创建态。进程正在被创建时，它的状态是“创建态”，在这个阶段操作系统会为进程分配资源、初始化PCB。
就绪态。当进程创建完成后，便进入“就绪态”，处于就绪态的进程已经具备运行条件，但由于没有空闲CPU，就暂时不能运行。
运行态。如果一个进程此时在CPU上运行，那么这个进程处于“运行态”。CPU会执行该进程对应的程序（执行指令序列）。
阻塞态，又称等待态。在进程运行的过程中，可能会请求等待某个事件的发生（如等待某种系统资源的分配，或者等待其他进程的响应）而暂停。
终止态。一个进程可以执行exit系统调用，请求操作系统终止该进程。系统首先将该进程置为终止态，然后进一步处理资源释放和回收（内存空间、PCB等）等工作。

进程状态的转换

注：一个进程从运行态变为阻塞态是主动的行为，而从阻塞态变为就绪态是被动的行为，需要其他相关进程的协助。

进程的组织

链接方式

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

索引方式

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

进程控制

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

使用“原语”实现进程控制。

原语是一种特殊的程序，它的执行具有原子性。也就是说，这段程序的运行必须一气呵成，不可中断。可以用“关中断指令”和“开中断指令”这两个特权指令实现原子性。

进程的创建

父子进程

允许一个进程创建另一个进程，此时创建者称为父进程，被创建的进程称为子进程。子进程可以继承父进程所拥有的资源。当子进程被撤销时，应将其从父进程那里获得的资源还给父进程。此外，在撤销父进程时，通常也会同时撤销其所有的子进程。

创建进程的时机

终端用户登录系统、作业调度、系统提供服务、用户程序的应用请求等都会引起进程的创建。

创建进程的操作

创建一个新进程的过程如下（创建原语）：

为新进程分配一个唯一的进程标识号，并申请一个空白PCB（PCB是有限的)。若PCB申请失败，则创建失败。
为进程分配其运行所需的资源，如内存、文件、I/O设备和CPU时间等（在PCB中体现）。这些资源或从操作系统获得，或仅从其父进程获得。如果资源不足（如内存），则并不是创建失败，而是处于创建态，等待内存资源。
初始化PCB，主要包括初始化标志信息、初始化CPU状态信息和初始化CPU控制信息，以及设置进程的优先级等。
若进程就绪队列能够接纳新进程，则将新进程插入就绪队列，等待被调度运行。

进程的终止

终止进程的时机

正常结束，表示进程的任务已完成并准备退出运行。
异常结束，表示进程在运行时，发生了某种异常事件，使程序无法继续运行，如存储区越界、保护错、
非法指令、特权指令错、运行超时、算术运算错、I/O故障等。
外界干预，指进程应外界的请求而终止运行，如操作员或操作系统干预、父进程请求和父进程终止。

终止进程的操作

终止的过程如下（终止原语）：

根据被终止进程的标识符，检索出该进程的PCB，从中读出该进程的状态。
若被终止进程处于运行状态，立即终止该进程的执行，将CPU资源分配给其他进程。
若该进程还有子孙进程，则通常需将其所有子孙进程终止（有些系统无此要求）。
将该进程所拥有的全部资源，或归还给其父进程，或归还给操作系统。
将该PCB从所在队列（链表）中删除。

进程的阻塞和唤醒

进程阻塞的时机

进程期待的某些事件未发生，如请求系统资源失败、等待某种操作的完成、新数据尚未到达或无新任务可做等。进程便通过调用阻塞原语（Block），使自己由运行态变为阻塞态。

阻塞是进程自身的一种主动行为，也因此只有处于运行态的进程才可能将其转为阻塞态。

进程阻塞的操作

阻塞原语的执行过程如下：

找到将要被阻塞进程的标识号（PID）对应的PCB。
若该进程为运行态，则保护其现场，将其状态转为阻塞态，停止运行。
将该PCB插入相应事件的等待队列，将CPU资源调度给其他就绪进程。

进程唤醒的时机

当被阻塞进程所期待的事件出现时，如它所期待的I/O操作已完成或其所期待的数据已到达，由有关进程（比如，释放该I/O设备的进程，或提供数据的进程）调用唤醒原语（Wakeup），将等待该事件的进程唤醒。

进程唤醒的操作

唤醒原语的执行过程如下：

在该事件的等待队列中找到相应进程的PCB。
将其从等待队列中移出，并置其状态为就绪态。
将该PCB插入就绪队列，等待调度程序调度。

注：Block原语和Wakeup原语必须成对使用。否则，阻塞进程将因不能被唤醒而永久地处于阻塞态。

进程通信

进程通信是指两个进程之间产生数据交互。有高级通信和低级通信两种，高级通信即下文的三种方式，低级通信为后文的PV操作。

进程是分配系统资源的单位（包括内存地址空间），因此各进程拥有的内存地址空间相互独立，为了保证安全，一个进程不能直接访问另一个进程的地址空间。

共享存储

在通信的进程之间存在一块可直接访问的共享空间,通过对这片共享空间进行写/读操作实现进程之间的信息交换。

为避免出错，各个进程对共享空间的访问应该是互斥的，各个进程可使用操作系统内核提供的同步互斥工具（如P、V操作）。

基于数据结构的共享（低级通信）：比如共享空间里只能放一个长度为10的数组。这种共享方式速度慢、限制多。

基于存储区的共享（高级通信）：操作系统在内存中划出一块共享存储区，数据的形式、存放位置都由通信进程控制，而不是操作系统。这种共享方式速度很快（最快的进程通信方式）。

消息传递

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

直接通信方式：消息发送进程要指明接收进程的ID，发生进程直接将消息发送给接收进程。

间接通信方式：通过“信箱”（中间实体）间接地通信。因此又称“信箱通信方式“（可以多个进程往同一个信箱发送消息，也可以多个进程从同一个信箱中接受消息）。

管道通信

“管道”是一个特殊的共享文件，又名pipe文件。其实就是在内存中开辟（受内存一页的大小约束）一个大小固定的内存缓冲区。

管道只能采用半双工通信，某一时间段内只能实现单向的传输。如果要实现双向同时通信，则需要设置两个管道。

管道机制必须实现互斥、同步、确认存在这三方面的协调能力。

管道中的数据一旦被读出，就彻底消失。因此，当多个进程读同一个管道时，可能会错乱。对此，通常有两种解决方案：

一个管道允许多个写进程，一个读进程（2014年408真题高教社官方答案）
允许有多个写进程，多个读进程，但系统会让各个读进程轮流从管道中读数据（Linux的方案，互斥锁或信号量）

线程的概念

线程的基本概念

引入进程的目的是更好地使多道程序并发执行，提高资源利用率和系统吞吐量；而引入线程（Threads）的目的则是减小程序在并发执行时所付出的时空开销，提高操作系统的并发性能。

线程最直接的理解就是轻量级进程，它是一个基本的CPU执行单元，也是程序执行流的最小单元，由线程ID、程序计数器、寄存器集合和堆栈组成。

线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其他线程共享进程所拥有的全部资源（因此，若一个线程出错，则可能影响整个进程运行，安全性降低）。

线程也有就绪、阻塞和运行三种基本状态。

引入线程后，进程的内涵发生了改变，进程只作为除CPU外的系统资源的分配单元（如打印机、内存地址空间等分配），而线程则作为CPU的分配单元。由于一个进程内部有多个线程，若线程的切换发生在同一个进程内部，则只需要很少的时空开销。

进程和线程的比较

调度

传统的操作系统中，拥有资源和独立调度的基本单位都是进程，每次调度都要进行上下文切换，开销较大。

在引入线程的操作系统中，进程是资源分配的基本单位，线程是独立调度的基本单位，且线程切换的代价远低于进程。在同一进程中，线程的切换不会引起进程切换。

并发性

在引入线程的操作系统中，不仅进程之间可以并发执行，而且一个进程中的多个线程之间亦可并发执行，甚至不同进程中的线程也能并发执行。

操作系统具有更好的并发性，提高了系统资源的利用率和系统的吞吐量。

拥有资源

进程是系统中拥有资源的基本单位，而线程不拥有系统资源，但线程可以访问其隶属进程的系统资源。

独立性

进程都拥有独立的地址空间和资源，除了共享全局变量，不允许其他进程访问。

某个进程中的线程对其他进程不可见。同一进程中的不同线程共享进程的地址空间和资源。

系统开销

传统的进程间并发，需要切换进程的运行环境，系统开销很大。线程间并发，如果是同一进程内的线程切换，则不需要切换进程环境，系统开销小。引入线程后，并发所带来的系统开销减小。

支持多处理器系统

对于传统单线程进程，不管有多少个CPU，进程只能运行在一个CPU上。对于多线程进程，可将进程中的多个线程分配到多个CPU上执行。

线程的属性

线程也有就绪、阻塞、运行三种基本状态。每个线程都有一个线程ID、线程控制块（TCB）。

线程几乎不拥有系统资源，同一进程的不同线程间共享进程的资源。由于共享内存地址空间，同一进程中的线程间通信甚至无需系统干预。

同一进程中的线程切换，不会引起进程切换；不同进程中的线程切换，会引起进程切换；切换同进程内的线程，系统开销很小；切换进程，系统开销较大。

线程实现的方式

用户级线程

用户级线程就是“从用户视角看能看到的线程”，由应用程序通过线程库实现，所有的线程管理工作都由应用程序负责（包括线程切换）。

在用户看来，有多个线程；但是在操作系统内核看来，意识不到线程的存在。对于设置了用户级线程的系统，其调度仍然以进程为单位进行。

优点：用户级线程的切换在用户空间即可完成，不需要切换到核心态，无需操作系统干预，线程管理的系统开销小，效率高。

缺点：当一个用户级线程被阻塞后，整个进程都会被阻塞，并发度不高；多个线程不可在多核处理机上并行运行。

内核级线程

内核级线程的管理工作由操作系统内核完成。线程调度、切换等工作都由内核负责，因此内核级线程的切换必然需要在核心态下才能完成。

操作系统会为每个内核级线程建立相应的TCB（线程控制块），通过TCB对线程进行管理。“内核级线程”就是“从操作系统内核视角看能看到的线程”。

优点：当一个线程被阻塞后，别的线程还可以继续执行，并发能力强。多线程可在多核处理机上并行执行。

缺点：一个用户进程会占用多个内核级线程，线程切换由操作系统内核完成，需要切换到核心态，因此线程管理的成本高，开销大。

多线程模型

用户级线程是“代码逻辑”的载体；内核级线程是“运行机会”的载体。一段“代码逻辑”只有获得了“运行机会”才能被CPU执行。

内核级线程才是处理机分配的单位。内核级线程中可以运行任意一个有映射关系的用户级线程代码，只有内核级线程中正在运行的代码逻辑都阻塞时，这个进程才会阻塞。

在支持内核级线程的系统中，根据用户级线程和内核级线程的映射关系，可以划分为几种多线程模型：

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

每个进程只被分配一个内核级线程，线程的调度和管理在用户空间完成。仅当用户线程需要访问内核时，才将其映射到一个内核级线程上，但每次只允许一个线程进行映射。

优点：线程管理是在用户空间进行的，无须切换到核心态，因而效率比较高。

缺点：如果一个线程在访问内核时发生阻塞，则整个进程都会被阻塞；在任何时刻，只有一个线程能够访问内核，多个线程不能同时在多个CPU上运行。

一对一模型：将每个用户级线程映射到一个内核级线程。

每个进程有与用户级线程数量相同的内核级线程，线程切换由内核完成，需要切换到核心态。

优点：当一个线程被阻塞后，允许调度另一个线程运行，所以并发能力较强。

缺点：每创建一个用户线程，相应地就需要创建一个内核线程，开销较大。

多对多模型：将n个用户级线程映射到m个内核级线程上，要求n≥m。

特点：既克服了多对一模型并发度不高的缺点，又克服了一对一模型的一个用户进程占用太多内核级线程而开销太大的缺点。此外，还拥有上述两种模型各自的优点（并发性强、效率高）。

线程的状态和与转换

线程的组织与控制

线程控制块通常包括：1）线程标识符；2）一组寄存器，包括程序计数器、状态寄存器和通用寄存器；3）线程运行状态，用于描述线程正处于何种状态；4）优先级；5）线程专有存储区，线程切换时用于保存现场等；6）堆栈指针，用于过程调用时保存局部变量及返回地址等。

处理机调度

调度的基本概念

在多道程序系统中，进程的数量往往多于CPU的个数，因此进程争用CPU的情况在所难免。

CPU调度是对CPU进行分配，即从就绪队列中按照一定的算法（公平、高效的原则）选择一个进程并将CPU分配给它运行，以实现进程并发地执行。

调度的三个层次

作业：一个具体的任务

用户向系统提交一个作业=用户让操作系统启动一个程序（来处理一个具体的任务）

高级调度

内存空间有限，有时无法将用户提交的作业全部放入内存。

高级调度（作业调度），按一定的原则从外存的作业后备队列中挑选一个作业调入内存，分配内存、I/O等妓院，并创建进程，进入就绪态。

作业调度是内存与辅存之间的调度，每个作业只调入一次，调出一次。作业调入时会建立PCB，调出时才撤销PCB。

低级调度

低级调度（进程调度/处理机调度），按照某种策略从就绪队列中选取一个进程，将处理机分配给它。

进程调度是操作系统中最基本的一种调度，在一般的操作系统中都必须配置进程调度。进程调度的频率很高，一般几十毫秒一次。

中级调度

引入中级调度的目的是提高内存利用率和系统吞吐量。

为此，将那些暂时不能运行的进程调至外存等待，此时进程的状态称为挂起态。当它们已具备运行条件且内存又稍有空闲时，由中级
调度来决定将外存上的那些已具备运行条件的挂起进程再重新调入内存，并修改其状态为就绪态，挂在就绪队列上等待。

中级调度实际上是存储器管理中的对换功能。

中级调度（内存调度），按照某种策略决定将哪个处于挂起状态的进程重新调入内存。一个进程可能会被多次调出、调入内存，因此中级调度发生的频率要比高级调度更高。

进程的七状态模型

暂时调到外存等待的进程状态为挂起状态（挂起态，suspend），挂起态又可以进一步细分为就绪挂起、阻塞挂起两种状态。

三层调度的联系、对比

作业调度为进程活动做准备，进程调度使进程正常活动起来。
中级调度将暂时不能运行的进程挂起，中级调度处于作业调度和进程调度之间。
作业调度次数少，中级调度次数略多，进程调度频率最高。
进程调度是最基本的，不可或缺。

进程调度的时机

进程调度（低级调度），就是按照某种算法从就绪队列中选择一个进程为其分配处理机。

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

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

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

在处理中断的过程中，中断处理过程复杂，与硬件密切相关，很难做到在中断处理过程中进行进程切换。
进程在操作系统内核程序临界区中。但是进程在普通临界区中是可以进行调度、切换的。
在原子操作过程中，原子操作不可中断，要一气呵成。

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

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

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

进程调度的方式

非剥夺调度方式，又称非抢占方式。

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

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

剥夺调度方式，又称抢占方式。

当一个进程正在处理机上执行时，如果有一个更重要或更紧迫的进程需要使用处理机，则立即暂停正在执行的进程，将处理机分配给更重要紧迫的那个进程。

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

进程的切换与过程

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

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

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

上下文切换

切换CPU到另一个进程需要保存当前进程状态并恢复另一个进程的状态，这个任务称为上下文切换。进程上下文采用进程PCB表示，包括CPU寄存器的值、进程状态和内存管理信息等。

当进行上下文切换时，内核将旧进程状态保存在其PCB中，然后加载经调度而要执行的新进程的上下文。在切换过程中，进程的运行环境产生实质性的变化。上下文切换的流程如下：

挂起一个进程，将CPU上下文保存到PCB，包括程序计数器和其他寄存器。
将进程的PCB移入相应的队列，如就绪、在某事件阻塞等队列。
选择另一个进程执行，并更新其PCB。
恢复新进程的CPU上下文（如：程序计数器、程序状态字、各种数据寄存器等处理机现场信息）。
跳转到新进程PCB中的程序计数器所指向的位置执行。

上下文切换的消耗

上下文切换通常是计算密集型的，即它需要相当可观的CPU时间，在每秒几十上百次的切换中，每次切换都需要纳秒量级的时间，所以上下文切换对系统来说意味着消耗大量的CPU时间。有些CPU提供多个寄存器组，这样，上下文切换就只需要简单改变当前寄存器组的指针。

上下文切换与模式切换

模式切换与上下文切换是不同的，模式切换时，CPU逻辑上可能还在执行同一进程。用户进程最开始都运行在用户态，若进程因中断或异常进入核心态运行，执行完后又回到用户态刚被中断的进程运行。用户态和内核态之间的切换称为模式切换，而不是上下文切换，因为没有改变当前的进程。上下文切换只能发生在内核态，它是多任务操作系统中的一个必需的特性。

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

调度器、闲逛进程

调度器/调度程序（scheduler）

②、③由调度程序引起，调度程序决定：调度算法、时间片大小

调度时机——什么事件会触发“调度程序”？

创建新进程
进程退出
运行进程阻塞
I/O中断发生（可能唤醒某些阻塞进程）
非抢占式调度策略，只有运行进程阻塞或退出才触发调度程序工作
抢占式调度策略，每个时钟中断或k个时钟中断会触发调度程序工作

不支持内核级线程的操作系统，调度程序的处理对象是进程。支持内核级线程的操作系统，调度程序的处理对象是内核线程。

闲逛进程

调度程序永远的备胎，没有其他就绪进程时，运行闲逛进程（idle）。

闲逛进程的特性：优先级最低、可以是0地址指令，占一个完整的指令周期（指令周期末尾例行检查中断）、能耗低。

调度算法的评价指标

CPU利用率

CPU利用率：指CPU“忙碌”的时间占总时间的比例。
$利用率=\frac{忙碌的时间}{总时间}$

例：某计算机只支持单道程序，某个作业刚开始需要在CPU上运行5秒，再用打印机打印输出5秒，之后再执行5秒，才能结束。在此过程中，CPU利用率、打印机利用率分别是多少？

答：CPU利用率= $\frac{5+5}{5+5+5}= 66.66\%$ ，打印机利用率= $\frac{5}{15}= 33.33\%$ 。

系统吞吐量

系统吞吐量：单位时间内完成作业的数量。
$系统吞吐量=\frac{总共完成了多少道作业}{总共花了多少时间}$

例：某计算机系统处理完10道作业，共花费100秒，则系统吞吐量为？
答：10/100=0.1道/秒。

周转时间

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

它包括四个部分：作业在外存后备队列上等待作业调度（高级调度）的时间、进程在就绪队列上等待进程调度（低级调度）的时间、进程在CPU上执行的时间、进程等待I/O操作完成的时间。后三项在一个作业的整个处理过程中，可能发生多次。
$周转时间=作业完成时间-作业提交时间\\平均周转时间=\frac{各作业周转时间之和}{作业数}\\带权周转时间=\frac{作业完成时间-作业提交时间}{作业实际运行时间}\\平均带权周转时间=\frac{各作业带权周转时间之和}{作业数}$

等待时间

等待时间，指进程/作业处于等待处理机状态时间之和，等待时间越长，用户满意度越低。
$等待时间 = 周转时间 - 运行时间 - I / O 操作时间（如果有）$

对于进程来说，等待时间就是指进程建立后等待被服务的时间之和，在等待I/O完成的期间其实进程也是在被服务的，所以不计入等待时间。

对于作业来说，不仅要考虑建立进程后的等待时间，还要加上作业在外存后备队列中等待的时间。

响应时间

响应时间，指从用户提交请求到首次产生响应所用的时间。

调度算法

先来先服务（FCFS）

先来先服务调度算法：按照到达的先后顺序调度，事实上就是等待时间越久的越优先得到服务。

主要从“公平”的角度考虑。

按照作业/进程到达的先后顺序进行服务。

用于作业调度时，考虑的是哪个作业先到达后备队列；用于进程调度时，考虑的是哪个进程先到达就绪队列。

非抢占式的算法。

优点：公平、算法实现简单。

缺点：排在长作业（进程）后面的短作业需要等待很长时间，带权周转时间很大，对短作业来说用户体验不好。即，FCFS算法对长作业有利，对短作业不利。

不会导致饥饿。

短作业优先（SJF）

短作业/进程优先调度算法：每次调度时选择当前已到达且运行时间最短的作业/进程。

追求最少的平均等待时间，最少的平均周转时间、最少的平均平均带权周转时间。

最短的作业/进程优先得到服务（所谓“最短”，是指要求服务时间最短）

既可用于作业调度，也可用于进程调度。用于进程调度时称为“短进程优先（SPF）算法”

SJF和SPF是非抢占式的算法。

优点：“最短的”平均等待时间、平均周转时间。

缺点：不公平。对短作业有利，对长作业不利。可能产生饥饿现象。另外，作业/进程的运行时间是由用户提供的，并不一定真实，不一定能做到真正的短作业优先。

会导致饥饿。如果长作业一直得不到服务，则称为“饿死”。

最短剩余时间优先（SRTN）

SJF的抢占式的版本。

每当有进程加入就绪队列改变时就需要调度，如果新到达的进程剩余时间比当前运行的进程剩余时间更短，则由新进程抢占处理机，当前运行进程重新回到就绪队列。另外，当一个进程完成时也需要调度。

注：

很多书上都会说“SJF调度算法的平均等待时间、平均周转时间最少”。

严格来说，这个表述是错误的，不严谨的。最短剩余时间优先算法得到的平均等待时间、平均周转时间还要更少。

应该加上一个条件**“在所有进程同时可运行时”或者说“在所有进程都几乎同时到达时”**，采用SJF调度算法的平均等待时间、平均周转时间最少。

如果不加上述前提条件，则应该说“抢占式的短作业/进程优先调度算法（最短剩余时间优先，SRNT算法）的平均等待时间、平均周转时间最少”。

如果选择题中遇到“SF算法的平均等待时间、平均周转时间最少”的选项，那最好判断其他选项是不是有很明显的错误，如果没有更合适的选项，那也应该选择该选项。

高响应比优先（HRRN）

高响应比优先算法：非抢占式的调度算法，只有当前运行的进程主动放弃CPU时（正常/异常完成，或主动阻塞），才需要进行调度，调度时计算所有就绪进程的响应比，选响应比最高的进程上处理机。

要综合考虑作业/进程的等待时间和要求服务的时间。

在每次调度时先计算各个作业/进程的响应比，选择响应比最高的作业/进程为其服务。

即可用于作业调度，也可用于进程调度。
$响应比=\frac{等待时间+要求服务时间}{要求服务时间}$

非抢占式的算法。因此只有当前运行的作业/进程主动放弃处理机时，才需要调度，才需要计算响应比。

综合考虑了等待时间和运行时间（要求服务时间）等待时间相同时，要求服务时间短的优先（SF的优点）要求服务时间相同时，等待时间长的优先（FCFS的优点）对于长作业来说，随着等待时间越来越久，其响应比也会越来越大，从而避免了长作业饥饿的问题。

不会导致饥饿。

时间片轮转（RR）

时间片轮转调度算法：轮流让就绪队列中的进程依次执行一个时间片（每次选择的都是排在就绪队列队头的进程）。

公平地、轮流地为各个进程服务，让每个进程在一定时间间隔内都可以得到响应，使得多个交互的用户能够及时得到响应。

按照各进程到达就绪队列的顺序，轮流让各个进程执行一个时间片（如100ms）。若进程未在一个时间片内执行完，则剥夺处理机，将进程重新放到就绪队列队尾重新排队。

用于进程调度（只有作业放入内存建立了相应的进程后，才能被分配处理机时间片）。

若进程未能在时间片内运行完，将被强行剥夺处理机使用权，因此时间片轮转调度算法属于抢占式的算法。由时钟装置发出时钟中断来通知CPU时间片已到。

优点：公平；响应快，适用于分时操作系统；

缺点：由于高频率的进程切换，因此有一定开销；不区分任务的紧急程度。

不会导致饥饿。

优先级调度算法

非抢占式的优先级调度算法：每次调度时选择当前已到达且优先级最高的进程。当前进程主动放弃处理机时发生调度。

抢占式的优先级调度算法：每次调度时选择当前已到达且优先级最高的进程。当前进程主动放弃处理机时发生调度。另外，当就绪队列发生改变时也需要检查是会发生抢占。

实时操作系统的出现，越来越多的应用场景需要根据任务的紧急程度来决定处理顺序。

调度时选择优先级最高的作业/进程。

既可用于作业调度，也可用于进程调度。甚至，还会用于在之后会学习的I/O调度中。

抢占式、非抢占式都有。区别在于：非抢占式只需在进程主动放弃处理机时进行调度即可，而抢占式还需在就绪队列变化时，检查是否会发生抢占。

优点：用优先级区分紧急程度、重要程度，适用于实时操作系统。可灵活地调整对各种作业/进程的偏好程度。

缺点：若源源不断地有高优先级进程到来，则可能导致饥饿。

会导致饥饿。

注：根据优先级是否可以动态改变，可将优先级分为静态优先级和动态优先级两种。静态优先级：创建进程时确定，之后一直不变。动态优先级：创建进程时有一个初始值，之后会根据情况动态地调整优先级。

多级反馈队列调度算法

对其他调度算法的折中权衡。

设置多级就绪队列，各级队列优先级从高到低，时间片从小到。
新进程到达时先进入第1级队列，按FCFS原则排队等待被分配时间片，若用完时间片进程还未结束，则进程进入下一级队列队尾。如果此时已经是在最下级的队列，则重新放回该队列队尾。
只有第k级队列为空时，才会为k+1级队头的进程分配时间片

用于进程调度。

抢占式的算法。在k级队列的进程运行过程中，若更上级的队列（1~k-1级）中进入了一个新进程，则由于新进程处于优先级更高的队列中，因此新进程会抢占处理机，原来运行的进程放回k级队列队尾。

对各类型进程相对公平（FCFS的优点）；每个新到达的进程都可以很快就得到响应（RR的优点）；短进程只用较少的时间就可完成（SPF的优点）；不必实现估计进程的运行时间（避免用户作假）；可灵活地调整对各类进程的偏好程度，比如CPU密集型进程、I/O密集型进程（拓展：可以将因I/O而阻塞的进程重新放回原队列，这样I/O型进程就可以保持较高优先级）。

会导致饥饿。

同步与互斥

进程同步

同步亦称直接制约关系，是指为完成某种任务而建立的两个或多个进程，这些进程因为需要协调它们的运行次序而等待、传递信息所产生的制约关系。同步关系源于进程之间的相互合作。

进程具有异步性的特征。异步性是指各并发执行的进程以各自独立的、不可预知的速度向前推进。操作系统要提供“进程同步机制”来解决异步问题。

进程互斥

进程的“并发”需要“共享”的支持。各个并发执行的进程不可避免的需要共享一些系统资源（比如内存，又比如打印机、摄像头这样的I/O设备）。有互斥共享方式和同时共享方式两种资源共享方式。

互斥，亦称间接制约关系。对临界资源（一个时间段内只允许一个进程使用的资源）的访问，必须互斥地进行。

进程互斥指当一个进程访问某临界资源时，另一个想要访问该临界资源的进程必须等待。当前访问临界资源的进程访问结束，释放该资源之后，另一个进程才能去访问临界资源。

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

遵循原则：

空闲让进。临界区空闲时，可以允许一个请求进入临界区的进程立即进入临界区；
忙则等待。当已有进程进入临界区时，其他试图进入临界区的进程必须等待；
有限等待。对请求访问的进程，应保证能在有限时间内进入临界区（保证不会饥饿）；
让权等待。当进程不能进入临界区时，应立即释放处理机，防止进程忙等待。

进程互斥的软件实现方法

单标志法

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

turn 变量背后的逻辑：表达谦让.

该算法可以实现每次只允许一个进程进入临界区。但两个进程必须交替进入临界区，若某个进程不再进入临界区，则另一个进程也将无法进入临界区，易造成资源利用不充分。若P0顺利进入临界区并从临界区离开，则此时临界区是空闲的，但P1并没有进入临界区的打算，而turn=1一直成立，则P0就无法再次进入临界区。

主要问题：违背”空闲让进“原则。

双标志先检查

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

flag[i] 背后的逻辑含义： “表达意愿”。

但是，如果按照①⑤②⑥…的顺序执行，P0和P1同时访问临界区。由于一开始都没有进程表达意愿，进程P0while循环检查没有进程有意愿后，在P0表达意愿前，进程P1进行进行是否有意愿，也发现没有进程有意愿访问临界区，则跳过while循环，进入表达意愿，但是由于两个进程都已经结束了检查意愿的过程，且结果都是可以访问，所以P0和P1都会访问临界区。

主要问题：违反“忙则等待”原则。

双标志法后检查

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

但是，如果①⑤②⑥…的顺序执行，在P0进程表达意愿后，检查其他进程意愿前，P1进程也表达意愿，则两个进程都检查到另一进程有访问意愿，那么两个进程都无法访问临界区。

主要问题：违背了“空闲让进”和“有限等待”原则，会因各进程都长期无法访问临界资源而产生“饥饿”现象。

Peterson算法

算法思想：结合双标志法、单标志法的思想，如果双方都想着进入临界区，可以让进程谦让。

进入区: 1.主动争取；2.主动谦让；3.检查对方是否也想使用，且是否自己表示谦让。

主要问题：遵循了空闲让进、忙则等待、有限等待三个原则，但是依然未遵循让权等待的原则。

进程互斥的硬件实现方法

中断屏蔽方法

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

优点：简单、高效。

缺点：系统效率降低；不适用于多处理机；只适用于操作系统内核进程，不适用于用户进程（因为开/关中断指令只能运行在内核态，这组指令如果能让用户随意使用会很危险）。

TestAndSet指令

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

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

若刚开始lock是false，则TSL返回的old值为false，while循环条件不满足，直接跳过循环，进入临界区。若刚开始lock是true，则执行TLS后old返回的值为true，while循环条件满足，会一直循环，直到当前访问临界区的进程在退出区进行“解锁”。

优点：实现简单，无需像软件实现方法那样严格检查是否会有逻辑漏洞；适用于多处理机环境。

缺点：不满足“让权等待”原则，暂时无法进入临界区的进程会占用CPU并循环执行TSL指令，从而导致“忙等”。

Swap指令

也叫Exchange指令，或简称XCHG指令。

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

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

优点：实现简单，无需像软件实现方法那样严格检查是否会有逻辑漏洞；适用于多处理机环境

缺点：不满足“让权等待”原则，暂时无法进入临界区的进程会占用CPU并循环执行TSL指令，从而导致“忙等”。

互斥锁

互斥锁（mutexlock）。一个进程在进入临界区时应获得锁；在退出临界区时释放锁。函数acquire()获得锁，而函数release()释放锁。

每个互斥锁有一个布尔变量available，表示锁是否可用。如果锁是可用的，调用acqiure()会成功，且锁不再可用。当一个进程试图获取不可用的锁时，会被阻塞，直到锁被释放。

acquire()或release()的执行必须是原子操作，因此互斥锁通常采用硬件机制来实现。

缺点：忙等待，当有一个进程在临界区中，任何其他进程在进入临界区时必须连续循环调用acquire()。当多个进程共享同一CPU时，就浪费了CPU周期。

因此，互斥锁通常用于多处理器系统，一个线程可以在一个处理器上等待，不影响其他线程的执行。

需要连续循环忙等的互斥锁，都可称为自旋锁（spin lock），如TSL指令、swap指令、单标志法。

特性：

需忙等，进程时间片用完才下处理机，违反“让权等待”。
优点是等待期间不用切换进程上下文，多处理器系统中，若上锁的时间短，则等待代价很低。
常用于多处理器系统，一个核忙等，其他核照常工作，并快速释放临界区。
不太适用于单处理机系统，忙等的过程中不可能解锁。

信号量机制

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

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

原语是一种特殊的程序段，其执行只能一气呵成，不可被中断。原语是由关中断/开中断指令实现的。

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

wait、signal原语常简称为P、V操作（来自荷兰语proberen和verhogen）。因此常把wait(S)、signal(S)两个操作分别写为P(S)、V(S)。

整型信号量

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

对信号量的操作只有三种，即初始化、P操作、V操作。

int S = 1;// 初始型整型信号量s，表示当前系统中可用的打印机资源数
void wait (int S){// wait 原语，相当于“进入区”        
    while (S <= 0);// 循环检查，是否当前资源已经不够了
    S--;// 如果资源数够，则占用一个资源
}
void signal (int S){// signal 原语，相当于“退出区”
    S++;// 使用完资源后，在退出区释放资源
}

Eg：某计算机系统中有一台打印机…

记录型信号量

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

/* 记录型信号量的定义 */
typedef struct {
    int value;// 剩余资源数
    struct process *L;// 等待队列
} Semaphore;
/* 某进程需要使用资源时，通过wait原语申请 */
void wait(Semaphore S) {
    S.value--;//先减后判断，会出现值为-1的情况
    if (S.value < 0) {
        //如果剩余资源数不够，使用block原语使进程从运行态进入阻塞态，并把挂到信号量 S 的等待队列（即阻塞队列）中。
        block (S.L);
    }
}
/*进程使用完资源后，通过signal 原语释放*/
void signal (Semaphore S) {
    s.value++;
    if (S.value <= 0) {
        //释放资源后， 若还有别的进程在等待这种资源，则使用wakeup原语唤醒等待队列中的一个进程，该进程从阻塞态变为就绪态。
        wakeup(S.L);
    }
}

S.value的初值表示系统中某种资源的数目。

对信号量S的一次P操作意味着进程请求一个单位的该类资源，因此需要执行S.value–，表示资源数减1，当S.value < 0时表示该类资源已分配完毕，因此进程应调用block原语进行自我阻塞（当前运行的进程从运行态变成阻塞态），主动放弃处理机，并插入该类资源的等
待队列S.L中。可见，该机制遵循了“让权等待”原则，不会出现“忙等”现象。

对信号量S的一次V操作意味着进程释放一个单位的该类资源，因此需要执行S.value++，表示资源数加1，若加1后仍是S.value <= 0，表示依然有进程在等待该类资源，因此应调用wakeup原语唤醒等待队列中的第一个进程（被唤醒进程从阻塞态变成就绪态）。

信号量实现互斥

分析步骤：

分析并发进程的关键活动，划定临界区（如：对临界资源打印机的访问就应放在临界区）
设置互斥信号量mutex，初值为1
在进入区P(mutex)——申请资源
在退出区V(mutex)——释放资源

/*记录型信号量的定义*/
typedef struct {
    int value;// 剩余资源数
    struct process *L;// 等待队列
} Semaphore;

/* 信号量机制实现互斥 */
Semaphore mutex = 1;

P1(){
    // ...
    P(mutex);// 使用临界区前加锁
    // 临界区代码段
    V(mutex);// 使用临界区后解锁
    // ...
}

P2(){
    // ...
    P(mutex);
    // 临界区代码段
    V(mutex);
    // ...
}

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

信号量实现同步

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

semaphere S=0;

P1(){
    代码 1;
    代码 2;
    V(S);
    代码 3;
}
P2(){
    P(S);
    代码 4;
    代码 5; 
    代码 6;
}

假设P1、P2并发执行，由于存在异步性，因此二者交替推进的次序是不确定的。若P2的“代码4”要基于P1的“代码1”和“代码2”的运行结果才能执行，那么我们就必须保证“代码4”一定是在“代码2”之后才会执行。这就是进程同步问题，让本来异步并发的进程互相配合，有序推进。

分析步骤：

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

信号量机制实现前驱关系

代码要求按如下前驱图所示的顺序来执行：

则对应的进程同步代码实现如下：

生产者消费者问题

问题描述

系统中有一组生产者进程和一组消费者进程，生产者进程每生产一个产品放入缓冲区，消费者进程每次从缓冲区中取出一个产品并使用。生产者、消费者共享一个初始为空、大小为n的缓冲区。只有缓冲区没满时，生产者才能把产品放入缓冲区，否则必须等待。只有缓冲区不空时，消费者才能从中取出产品，否则必须等待。缓冲区是临界资源，各进程必须互斥地访问。

问题分析

PV操作题目分析步骤：

关系分析。找出题目中描述的各进程，分析它们之间的同步、互斥关系。
整理思路。根据各进程的操作流程确定P、V操作的大致顺序。
设置信号量，并根据题目条件确定信号量初值（互斥信号量初值一般设为1，同步信号量初值根据题设条件确定）。

根据题设，分析有：

同步关系1，缓冲区满时，生产者要等待消费者取走产品。
同步关系2。缓冲区空时（即没有产品时），消费者要等待生产者放入产品。
互斥关系，缓冲区需要互斥访问。

如何实现

//信号量设置
semaphore mutex=1;//互斥信号量，实现对缓冲区的互斥访问
semaphore empty=n;//同步信号量，空闲缓冲区的数量
semaphore full=0;//同步信号量，产品的数量

//生产者进程
producer(){
    while(1){
        生产一个产品;
        P(empty);//消耗一个空闲缓冲区，如果此时缓冲区没有空闲，则会阻塞生产者进程
        P(mutex);//缓冲区的互斥访问
        产品放入缓冲区;
        V(mutex);//缓冲区解锁
        V(full);//增加一个产品
    }
}

//消费者进程
consumer(){
    while(1){
        P(full);//消耗一个产品，如果此时没有产品，则会阻塞消费者进程
        P(mutex);//缓冲区的互斥访问
        从缓冲区取出一个产品;
        V(mutex);//缓冲区解锁
        V(empty);//增加一个空闲缓冲区
        使用产品;
    }
}

需要注意的是：

实现互斥是在同一进程中进行一对PV操作。如P(mutex)和V(mutex)将对临界资源的访问包裹起来，实现互斥访问。

实现两进程的同步关系，是在其中一个进程中执行P，另一进程中执行V。如系统开始时full=0，此时消费者进程需要在生产者进程将产品放入缓冲区之后才能执行取产品操作（消费者进程执行到 P(full)会将进程阻塞，直到生产者进程执行V(full)操作增加一个产品后，才会继续执行消费者进程）。

注：实现互斥的P操作一定要在实现同步的P操作之后，否则会导致死锁。V操作不会导致进程阻塞，因此两个V操作顺序可以交换。

多生产者多消费者问题

问题描述

桌子上有一只盘子，每次只能向其中放入一个水果。爸爸专向盘子中放苹果，妈妈专向盘子中放橘子，儿子专等着吃盘子中的橘子，女儿专等着吃盘子中的苹果。只有盘子空时，爸爸或妈妈才可向盘子中放一个水果。仅当盘子中有自己需要的水果时，儿子或女儿可以从盘子中取出水果。

问题分析

PV操作题目分析步骤：

关系分析。找出题目中描述的各进程，分析它们之间的同步、互斥关系。
整理思路。根据各进程的操作流程确定P、V操作的大致顺序。
设置信号量，并根据题目条件确定信号量初值（互斥信号量初值一般设为1，同步信号量初值根据题设条件确定）。

根据题设，分析有：

互斥关系，对盘子（即缓冲区）的访问要互斥进行。
同步关系1，父亲将苹果放入缓冲区后，女儿才能取苹果。
同步关系2，母亲将橘子放入缓冲区后，儿子才能取橘子。
同步关系3，女儿或儿子取走缓冲区内容后，父亲或母亲才能放入水果。

如何实现

//信号量设置
semaphore mutex=1;//互斥信号量，盘子缓冲区的互斥访问
semaphore apple=0;//同步信号量，盘子中的苹果数量
semaphore orange=0;//同步信号量，盘子中橘子的数量
semaphore plate=1;//同步信号量，盘子中可以放多少水果

//父亲进程
dad(){
    while(1){
        准备一个苹果;
        P(plate);//盘中可放水果数量减一，如果女儿或儿子没有取走水果，则进程被阻塞，无法放入水果
        P(mutex);//对盘子的互斥访问
        把苹果放入盘子;
        V(mutex);//解锁盘子
        v(apple);//增加苹果的数量
    }
}

//母亲进程
mom(){
    while(1){
        准备一个橘子;
        P(plate);
        P(mutex);
        把橘子放入盘子;
        V(mutex);
        v(orange);
    }
}

//女儿进程
daughter(){
    while(1){
        P(apple);//取出苹果，如果父亲没有放入苹果，则女儿进被阻塞。
        P(mutex);//互斥访问临界资源
        从盘中取出苹果;
        V(mutex);
        V(plate);//增加盘中可放水果数量，以便唤醒父亲或母亲进程
        吃掉苹果;
    }
}

//儿子进程
son(){
    while(1){
        P(orange);
        P(mutex);
        从盘中取出橘子;
        V(mutex);
        V(plate);
        吃掉橘子;
    }
}

此处值得注意的是：

即使不设置专门的互斥变量mutex，也不会出现多个进程同时访问盘子的现象。

原因在于本题中的缓冲区大小为1，在任何时刻，apple、orange、plate三个同步信号量中最多只有一个是1。因此在任何时刻，最多只有一个进程的P操作不会被阻塞，并顺利地进入临界区。

注：如果盘子（缓冲区）可放水果数量为2，则必须设置互斥信号量，否则会导致缓冲区数据覆盖问题。

注：实现互斥的P操作一定要在实现同步的P操作之后，否则可能引起“死锁”。

##吸烟者问题

问题描述

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

问题分析

PV操作题目分析步骤：

关系分析。找出题目中描述的各进程，分析它们之间的同步、互斥关系。
整理思路。根据各进程的操作流程确定P、V操作的大致顺序。
设置信号量，并根据题目条件确定信号量初值（互斥信号量初值一般设为1，同步信号量初值根据题设条件确定）。

根据题设，分析有：

注：此问题我们看到供应者每次提供两种物品，抽烟者每次取走两种物品，我们可以把两种物品打一个组合，则供应者每次提供一种组合，抽烟者每次取走一种组合。

互斥关系，桌子是临界资源，缓冲区大小为1，需要互斥访问。
同步关系1，桌子上放置组合一后，第一个抽烟者才可以取走物品。
同步关系2，桌子上放置组合二后，第二个抽烟者才可取走物品。
同步关系3，桌子上放置组合三后，第三个抽烟者才可以取走物品。
同步关系4，抽烟者取走物品后，供应者才可以放置组合。

如何实现

//信号量设置
semaphore offer1 = 0; //同步信号量，桌上组合一的数量
semaphore offer2 = 0; //同步信号量，桌上组合二的数量
semaphore offer3 = 0; //同步信号量，桌上组合三的数量
semaphore finish = 0; //同步信号量，抽烟是否完成，空闲缓冲区数量
int i = 0; //用于实现“三个抽烟者轮流抽烟”

//供应者进程
provider(){
    while(1){
        if(i==0){
            将组合一放在桌上;
            V(offer1);
        }else if(i==1){
            将组合二放在桌上;
            V(offer2);
        }else if(i==2){
            将组合三放在桌上;
            V(offer3)
        }
        i=(i+1)%3;
        P(finish);
    }
}

smoker1(){
    while(1){
        P(offer1);
        从桌上拿走走组合一;
        卷烟;
        抽掉;
        V(finish);
    }
}

smoker2(){
    while(1){
        P(offer2);
        从桌上拿走走组合二;
        卷烟;
        抽掉;
        V(finish);
    }
}

smoker3(){
    while(1){
        P(offer3);
        从桌上拿走走组合三;
        卷烟;
        抽掉;
        V(finish);
    }
}

此处，值得注意的是：

缓冲区大小为1，同一时刻，四个同步信号量中至多有一个的值为1，我们可以省去互斥信号量的设置，系统也不会发生死锁。

代码中增添了i变量，利用该变量，我们实现轮流供应不同组合的操作。

读者写者问题

问题描述

有读者和写者两组并发进程，共享一个文件，当两个或两个以上的读进程同时访问共享数据时不会产生副作用，但若某个写进程和其他进程（读进程或写进程）同时访问共享数据时则可能导致数据不一致的错误。因此要求：①允许多个读者可以同时对文件执行读操作；②只允许一个写者往文件中写信息；③任一写者在完成写操作之前不允许其他读者或写者工作；④写者执行写操作前，应让已有的读者和写者全部退出。

问题分析

PV操作题目分析步骤：

关系分析。找出题目中描述的各进程，分析它们之间的同步、互斥关系。
整理思路。根据各进程的操作流程确定P、V操作的大致顺序。
设置信号量，并根据题目条件确定信号量初值（互斥信号量初值一般设为1，同步信号量初值根据题设条件确定）。

根据题设，分析有：

互斥关系1，写进程与写进程对缓冲区的互斥访问。
互斥关系2，写进程与读进程对缓冲区的互斥访问。

注：

这两个互斥关系都是对同一个临界资源的访问，所以只需要设置一个互斥信号量。

因为可以有多个读进程同时读访问临界资源，且第一个读进程需要对临界资源上锁，最后一个读进程需要对临界资源解锁，则需要一个变量记录读进程的个数，且每个读进程互斥地修改这个变量。

如何实现

//信号量
semaphore rw=1; //互斥信号量，用于实现对共享文件的互斥访问
semaphore mutex = 1;//互斥信号量，用于保证对count变量的互斥访问
int count = 0; //记录当前有几个读进程在访问文件

writer(){
    while(1){
        P(rw);
        写文件;
        V(rw);
    }
}

reader(){
    while(1){
        P(mutex);
        if(count==0){
            P(rw);
        }
        count++;
        V(mutex);
        读文件;
        P(mutex);
        count--;
        if(count==0){
            V(rw);
        }
        V(mutex);
    }
}

注：在上述算法中，只要有读进程还在读，写进程就要一直阻塞等待，可能“饿死”。因此，这种算法中，读进程是优先的。

//信号量
semaphore rw = 1; 
semaphore mutex = 1;
int count = 0;
semaphore w = 1;//用于实现写优先

writer(){
    while(1){
        P(w);
        P(rw);
        写文件;
        V(rw);
        V(w);
    }
}

reader(){
    while(1){
        P(w);
        P(mutex);
        if(count==0){
            P(rw);
        }
        count++;
        V(mutex);
        V(w);
        读文件;
        P(mutex);
        count--;
        if(count==0){
            V(rw);
        }
        V(mutex);
    }
}

值得注意的是：

此种算法加入了互斥信号量w，对于读读，写写，写读（分别代表进程并发执行），此信号量都没有影响，与读优先算法效果相同。

但是对于读写并发，在第一种算法中，在读文件的过程中只要在最后一个进程在V(rw)之前，写进程会一直堵塞；而在第二种算法中，在读进程V(w)后，写进程可以执行P(W)，将余下想读文件的读进程阻塞在P(w)上。

总结：

在这种算法中，连续进入的多个读者可以同时读文件；写者和其他进程不能同时访问文件；写者不会饥饿，但也并不是真正的“写优先”，而是相对公平的先来先服务原则。这种算法也称为“读写公平法”。

哲学家进餐问题

问题描述

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

问题分析

PV操作题目分析步骤：

关系分析。找出题目中描述的各进程，分析它们之间的同步、互斥关系。
整理思路。根据各进程的操作流程确定P、V操作的大致顺序。
设置信号量，并根据题目条件确定信号量初值（互斥信号量初值一般设为1，同步信号量初值根据题设条件确定）。

根据题设，分析有：

互斥关系，5位哲学家与左右邻居对其中间的筷子的访问是互斥关系。
此问题中，每个哲学家（进程）需要两个临界资源才能继续进行，需要注意死锁问题。
信号量设置。定义互斥信号量数组chopstick[5]={1,1,1,1,1}用于实现对5个筷子的互斥访问。并对哲学家按0~4编号，哲学家i左边的筷子编号为i，右边的筷子编号为(i+1)%5。

防止死锁发生：

对哲学家施加某些限制，如最多只允许四个哲学家同时进餐。
要求奇数号哲学家先拿左边的筷子，而偶数号哲学家刚好相反。
仅当一个哲学家左右两支筷子都可用时允许拿起筷子。

如何实现

//信号量设置
semaphore chopstick[5]={1,1,1,1,1};
semaphore mutex = 1; //互斥地取筷子

Pi (){ //i号哲学家的进程
	while(1){
		P(mutex);
		P(chopstick[i]); //拿左
		P(chopstick[(i+1)%5]); //拿右
		V(mutex);
		吃饭;
		V(chopstick[i]); //放左
		V(chopstick[(i+1)%5]); //放右
		思考;
    }
}

算法采用了第三种防止死锁的方法，但这种设计不能保证只有两边的筷子都可用时才允许哲学家拿起筷子（左右两边的筷子都在却暂时无法取得，或者右边的筷子不可而仍然会先拿起左边的筷子）。

即，某个哲学家可能拿起左边筷子而被右侧筷子阻塞（右不可用却取左），此时其他哲学家被P(mutex)阻塞（左右可用却不可取），某个哲学家（上文同某个）等待正在吃饭的哲学家放下筷子后，便可以拿起右边的筷子。

管程

在信号量机制中，每个要访问临界资源的进程都必须自备同步的PV操作，大量分散的同步操作给系统管理带来了麻烦，且容易因同步操作不当而导致系统死锁。

于是，便产生了一种新的进程同步工具一一管程。管程的特性保证了进程互斥，无须程序员自已实现互斥，从而降低了死锁发生的可能性。同时管程提供了条件变量，可以实现进程同步。

管程的定义

利用共享数据结构抽象地表示系统中的共享资源，而将对该数据结构实施的操作定义为一组过程。进程对共享资源的申请、释放等操作，都通过这组过程来实现，这组过程还可以根据资源情况，或接受或阻塞进程的访问，确保每次仅有一个进程使用共享资源，这样就可以统一管理对共享资源的所有访问，实现进程互斥。

这个代表共享资源的数据结构，以及由对该共享数据结构实施操作的一组过程所组成的资源管理程序，称为管程（monitor）。

管程定义了一个数据结构和能为并发进程所执行（在该数据结构上）的一组操作，这组操作能同步进程和改变管程中的数据。

由上述定义可知，管程由4部分组成：

管程的名称；
局部于管程内部的共享数据结构说明：
对该数据结构进行操作的一组过程（或函数）；
对局部于管程内部的共享数据设置初始值的语句。

monitor Demo{//定义一个名为Demo的管程
    共享数据结构S;//定义共享数据结构，对应系统中某种资源
    init_code(){//对共享数据结构初始化的语句
        S=5;//初始资源数等于5
    }
    take_away(){//过程1：申请一个资源
        对共享数据结构x的一系列处理;
        S--;//可用资源数-1
    	......
    }
    give back(){//过程2：归还一个资源
        对共享数据结构x的一系列处理;
        S++;//可用资源数+1
        ......
    }
}

管程将对共享资源的操作封装起来，管程内的共享数据结构只能被管程内的过程所访问。一个进程只有通过调用管程内的过程才能进入管程访问共享资源。
每次仅允许一个进程进入管程，从而实现进程互斥。若多个进程同时调用，则只有某个进程运行完它调用的过程后，下一进程才能开始运行它调用的过程。即各进程只能串行执行管程内的过程，这一特性保证了进程互斥访问。

注：管程是语法范围。你可以把管程当工具去使用，但是不能创建和撤销管程。类比地看，管程相当于Java中的抽象类。这些抽象模块定义了数据该怎么用，数据的名字叫什么，但是没有把数据直接放进去。再通俗点讲，管程相当于一个函数。传入参数(给管程设置打印机初值)就可以使用它提供的功能(read,write操作)，这种调用过程是由进程实现的，但是调用≠创建或撤销。

条件变量

将阻塞原因定义为条件变量condition。通常，一个进程被阻塞的原因可以有多个，因此在管程中设置了多个条件变量。每个条件变量保存了一个等待队列，用于记录因该条件变量而阻塞的所有进程。

对条件变量只能进行两种操作，即wait和signal。

x.wait：当x对应的条件不满足时，正在调用管程的进程调用x.wait将自已插入x条件的等待队列，并释放管程。此时其他进程可以使用该管程。

x.signal：x对应的条件发生了变化，则调用x.signal，唤醒一个因x条件而阻塞的进程。

monitor Demo{
    共享数据结构S;
	condition x;//定义一个条件变量x
    init_code(){......}
    take_away(){
        if(S<=0)	x.wait();//资源不够，在条件变量x上阻塞
        等待资源足够，分配资源，做一系列相应处理;
    }
    give back(){
        归还资源，做一系列相应处理;
        if(有进程在等待)	x.signal();//唤醒一个阻塞进程
    }
}

条件变量和信号量的比较：

相似点：条件变量的wait/signal操作类似于信号量的P/V操作，可以实现进程的阻塞/唤醒。
不同点：条件变量是“没有值”的，仅实现了“排队等待”功能；而信号量是“有值”的，信号量的值反映了剩余资源数，而在管程中，剩余资源数用共享数据结构记录。

死锁

死锁的概念

死锁的定义

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

发生死锁后若无外力干涉，这些进程都将无法向前推进。

死锁、饥饿、死循环

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

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

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

死锁产生的必要条件

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

互斥条件。只有对必须互斥使用的资源的争抢才会导致死锁。
不剥夺条件。进程所获得的资源在未使用完之前，不能由
其他进程强行夺走，只能主动释放。
请求和保持条件。进程已经保持了至少一个资源，但又提
出了新的资源请求，而该资源又被其他进程占有，此时请
求进程被阻塞，但又对自己已有的资源保持不放。
循环等待条件。存在一种进程资源的循环等待链，链中的
每一个进程已获得的资源同时被下一个进程所请求。

注：发生死锁一定有循环等待，但是循环等待时不一定发生死锁。如果同类资源数大于1，即使循环等待，也未必发生死锁；如果每类资源只有一个，则循环等待是死锁的充分必要条件。

死锁发生的时机

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

总之，对不可剥夺资源的不合理分配，可能导致死锁。

死锁的处理策略

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

预防死锁

一种静态策略，不允许死锁发生。

破坏互斥条件

如果把只能互斥使用的资源改造为允许共享使用，则系统不会进入死锁状态。比如: SPOOLing技术。操作系统可以采用SPOOLing 技术把独占设备在逻辑上改造成共享设备。比如，用SPOOLing技术将打印机改造为共享设备…

缺点：并不是所有的资源都可以改造成可共享使用的资源。并且为了系统安全，很多地方还必须保护这种互斥性。因此，很多时候都无法破坏互斥条件。

破坏不剥夺条件

当某个进程请求新的资源得不到满足时，它必须立即释放保持的所有资源，待以后需要时再重新申请。也就是说，即使某些资源尚未使用完，也需要主动释放，从而破坏了不可剥夺条件。
当某个进程需要的资源被其他进程所占有的时候，可以由操作系统协助，将想要的资源强行剥夺。这种方式一般需要考虑各进程的优先级（比如：剥夺调度方式，就是将处理机资源强行剥夺给优先级更高的进程使用）。

缺点：

实现起来比较复杂。
释放已获得的资源可能造成前一阶段工作的失效。因此这种方法一般只适用于易保存和恢复状态的资源，如CPU。
反复地申请和释放资源会增加系统开销，降低系统吞吐量。
若采用方案一，意味着只要暂时得不到某个资源，之前获得的那些资源就都需要放弃，以后再重新申请。如果一直发生这样的情况，就会导致进程饥饿。

破坏请求和保持条件

采用静态分配方法，即进程在运行前一次申请完它所需要的全部资源，在它的资源未满足前，不让它投入运行。一旦投入运行后，这些资源就一直归它所有，该进程就不会再请求别的任何资源。

缺点：有些资源可能只需要用很短的时间，因此如果进程的整个运行期间都一直保持着所有资源，就会造成严重的资源浪费，资源利用率极低。另外，该策略也有可能导致某些进程饥饿。

破坏循环等待条件

采用顺序资源分配法。首先给系统中的资源编号，规定每个进程必须按编号递增的顺序请求资源，同类资源（即编号相同的资源）一次申请完。

原理分析：一个进程只有已占有小编号的资源时，才有资格申请更大编号的资源。按此规则，已持有大编号资源的进程不可能逆向地回来申请小编号的资源，从而就不会产生循环等待的现象。

在任何一个时刻，总有一个进程拥有的资源编号是最大的，那这个进程申请之后的资源必然畅通无阻。因此，不可能出现所有进程都阻塞的死锁现象。

缺点：

不方便增加新的设备，因为可能需要重新分配所有的编号；
进程实际使用资源的顺序可能和编号递增顺序不一致，会导致资源浪费；
必须按规定次序申请资源，用户编程麻烦。

避免死锁

一种动态策略，不允许死锁发生。

安全序列、不安全状态

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

安全序列可能有多个。

如果分配了资源之后，系统中找不出任何一个安全序列，系统就进入了不安全状态。这就意味着之后可能所有进程都无法顺利的执行下去。

如果有进程提前归还了一些资源，那系统也有可能重新回到安全状态。

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

###银行家算法

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

具体设计：

假设系统中有n个进程，m种资源。每个进程在运行前先声明对各种资源的最大需求数，则可用一个n*m的矩阵（可用二维数组实现）表示所有进程对各种资源的最大需求数。不妨称为最大需求矩阵Max，Max[i, j]=K表示进程Pi最多需要K个资源
Rj。

同理，系统可以用一个n*m的分配矩阵Allocation表示对所有进程的资源分配情况。Max – Allocation =Need矩阵，表示各进程最多还需要多少各类资源。

另外，还要用一个长度为m的一维数组Available表示当前系统中还有多少可用资源。

某进程Pi向系统申请资源，可用一个长度为m的一维数组Requesti表示本次申请的各种资源量。

各矩阵之间的关系：

Available = Available - Requesti;
Allocation[i, j] = Allocation[i, j] + Requesti[j];
Need[i, j] = Need[i, j] – Requesti[j]

银行家算法步骤

如果Requesti[j]≤Need[i, j] (0≤j≤m)便转向2；否则认为出错。（比较进程所申请的资源是否小于所需要的资源数）
如果Requesti[j]≤Available[j] (0≤j≤m)便转向3；否则表示尚无足够资源，Pi必须等待。（比较进程申请的资源是否小于可分配的资源数）
操作系统试着把资源分配给进程Pi，并修改相应的数据（并非真的分配，修改数值只是为了做预判）。
操作系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。若安全，才正式分配；否则，恢复相应数据，让进程阻塞等待。

安全性算法步骤

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

检测和解除

该策略允许死锁发生。

死锁的检测

资源分配图

两种结点，两种边。

进程结点：对应一个进程。

资源结点：对应一类资源，一类资源可能有多个。

请求边：进程结点一>资源结点：表示进程想申请几个资源（每条边代表一个）。

分配边：资源节点一>进程结点：表示已经为进程分配了几个资源（每条边代表一个）。

检测死锁的算法

在资源分配图中，找出既不阻塞又不是孤点的进程Pi（找出一个Pi具有请求边，且所有请求边申请的资源数小于该资源剩余的资源数）。消去它所有的请求边和分配边，使之成为孤立的结点。
进程Pi所释放的资源，可以唤醒某些因等待这些资源而阻塞的进程，原来的阻塞进程可能变为非阻塞进程。根据1中的方法进行一系列简化后，若能消去图中所有的边，则称该图是可完全简化的。

死锁定理：如果某时刻系统的资源分配图是不可完全简化的，那么此时系统死锁。

死锁的解除

一旦检测出死锁的发生，就应该立即解除死锁。

注：利用死锁检测算法化简资源分配图后，为消去所有边的进程就是死锁进程（不是所有进程都是死锁进程）。

解除死锁的方法：

资源剥夺法。挂起（暂时放到外存上）某些死锁进程，并抢占它的资源，将这些资源分配给其他的死锁进程。但是应防止被挂起的进程长时间得不到资源而饥饿。
撤销进程法（或称终止进程法）。强制撤销部分、甚至全部死锁进程，并剥夺这些进程的资源。这种方式的优点是实现简单，但所付出的代价可能会很大。
进程回退法。让一个或多个死锁进程回退到足以避免死锁的地步。这要求系统要记录进程的历史信息，设置还原点。

豆奶特浓6

关注

31
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
408操作系统知识点——第二章进程与线程

进程管理是操作系统的核心，也是每年必考的重点。其中，进程的概念、进程调度、信号量机制实现同步和互斥、进程死锁等更是重中之重，必须深入掌握。需要注意的是，除选择题外，本章还容易出综合题，其中信号量机制实现同步和互厅、进程调度算法和死锁等都可能命制综合题，如利用信号量进行进程同步就在往年的统考中频繁出现。
复制链接

扫一扫