【操作系统】进程、线程基础知识

进程

我们编写的代码知识一个存储在硬盘的静态文件，通过编译后就会生成二进制可执行文件，当我们运行这个可执行文件后，它会被装到内存中，接着CPU会执行程序中的每一条指令，那么这个运行中的程序，就被称为进程。

现在我们考虑有一个会读取硬盘文件数据的程序被执行了，那么当运行到读取文件的指令时，就回去从硬盘读取数据，但是硬盘的读写速度是非常慢的，那么在这个时候，如果CPU傻傻的等硬盘返回数据的话，那CPU的利用率是非常低的。

所以，当进程要从硬盘读取数据时，CPU不需要阻塞等到数据的返回，而是去执行另外的进程。当硬盘数据返回时，CPU会收到中断，于是CPU在继续运行这个进程。

这种多个程序、交替执行的思想，就有CPU管理多个进程的初步想法。

对于一个支持多进程的系统，CPU会从一个进程快速切换至另一个进程，期间每个进程各运行几十或几百个毫秒。

虽然单核的CPU在某一个瞬间，只能运行一个进程。但在1秒钟期间，它可能会运行多个进程，这样就产生并行的错觉，实际上这是并发。

并发和并行有什么区别呢？

 进程的状态

进程有着运行-暂停-运行的活动规律，一般来说，一个进程并不是自始至终连续不停地运行的，它与并发执行中的其他进程的执行时相互制约的。

它有时处于运行状态，有时又由于某种原因而暂停运行处于等待状态，当使它暂停的原因消失后，它又进入准备运行状态。

所以，在一个进程的活动期间至少具备三种基本状态，即运行状态、就绪状态、阻塞状态。

上图中的各个状态的意义：

• 运行状态：该时刻进程占用CPU。
• 就绪状态：可运行，由于其他进程处于运行状态而暂时停止运行
• 阻塞状态：该进程正在等待某一事件发生（如等待输入、输入等操作的完成）而暂停停止运行，这时，即使给他CPU控制权，它也无法运行。

当然，进程好友另外两个基本状态：

• 创建状态：进程正在被创建时的状态；
• 结束状态：进程正在从系统中消失时的状态。

于是，一个完整的进程状态的变迁如下图：

进程的状态变迁：

• NULL->创建状态：一个新进程被创建时的第一个状态。
• 创建状态->就绪状态：当进程被创建完成并初始化后，一切就绪准备运行时，变为就绪状态，这个过程是很快的。
• 就绪态->运行状态：处于就绪状态的进程被操作系统的进程调度器选中后，就分配给CPU正式运行该进程。
• 运行状态->结束状态：当进程已经运行完成或出错时，会被操作系统作结束状态处理。
• 运行状态->阻塞状态：当进程请求某个事件且必须等待时，例如请求I/O事件。
• 阻塞状态->就绪状态：当进程要等待的事件完成是，他从阻塞状态变到就绪状态。

如果有大量阻塞状态的进程，进程可能会占用着物理内存空间，显然不是我们所希望的，毕竟物理内存空间是有限的，被阻塞状态的进程占用着物理内存就是一种浪费内存的行为。

所以，在虚拟内存管理的操作系统中，通常会把阻塞状态的进程的物理内存空间换出到硬盘，等需要再次运行的时候，再从硬盘换入到物理内存。

那么，就需要一个新的状态，来描述进程没有占用实际的物理内存空间的情况，这个状态就是挂起状态。这跟阻塞状态是不一样的，阻塞状态是等待某个事件的返回。

另外，挂起状态可以分为两种：

• 阻塞挂起状态：进程在外存（硬盘）并等待某个事件的出现
• 就绪挂起状态：进程在外存（硬盘），但只要进入内存，即刻立即运行。

这两种挂起状态加上前面的五种状态，就变成了七种状态变迁了：

导致进程挂起的原因不只是因为进程所使用的的内存空间不在物理内存，还包括如下情况：

• 通过sleep让进程间歇性挂起，其工作原理是设置一个定时器，到期后唤醒进程。
• 用户希望挂起一个程序的执行，比如在Linux中用Ctrl+Z挂起进程。

进程的控制结构

在操作系统中，使用进程控制块（process control block, PCB）数据结构来描述进程的。

PCB是进程存在的唯一标识，这意味着一个进程的存在，必然会有一个PCB，如果进程消失了，那么PCB也会随之消失。

PCB具体包含什么信息

进程描述信息：

• 进程标识符：标识各个进程，每个进程都有一个并且唯一的标识符；
• 用户标识符：进程归属的用户，用户标识符主要为共享和保护服务；

进程控制和管理信息：

• 进程当前状态,如new/ready/running/waiting或blocked等。
• 进程优先级：进程抢占CPU是的优先级；

资源分配清单：

• 有关内存地址空间或虚拟地址空间的信息，所打开文件的列表和所使用的的I/O设备信息。

CPU相关信息：

• CPU中各个寄存器的值，当进程被切换时，CPU的状态信息都会被保存在响应的PCB中，以便进程重新执行时，能从断点处继续执行。

每个PCB是如何组织的呢？

通常是通过链表的方式进行组织，把具有相同状态的进程链接在一起，组成各种队列。比如：

• 将所有处于就绪状态的进程链在一起，称为就绪队列；
• 把所有因等待某事件而处于等待状态的进程链在一起就组成各种阻塞队列；
• 另外，对于运行队列在单核CPU系统中则只有一个运行指针了，因为单核CPU在某个事件，只能运行一个程序。

那么，就绪队列和阻塞队列链表的组织形式如下图所示：

 除了连接的组织方式，还有索引方式，它的工作原理：将同一状态的进程组织在一个索引表中，索引表项指向相应的PCB，不同状态对应不同的索引表。

一般会选择链表，因为可能会面临进程创建，销毁等调度导致进程状态发生变化，所以链表能够更加灵活的插入和删除。

进程的控制

进程的控制不要包含进程的创建、终止、阻塞、唤醒的过程，这些过程也就是进程的控制。

1.创建进程

操作系统允许一个进程创建另一个进程，而且允许子进程继承父进程所拥有的资源，当子进程被终止时，其在父进程处继承的资源应当还给父进程，同时，终止父进程时同时也会终止其所有的子进程。

注意：Linux操作系统对于终止有子进程的父进程，会把子进程交给1号进程接管。

创建进程的过程如下：

• 为新进程分配一个唯一的进程标识号，并申请一个空白的PCB，PCB是有限的，若申请失败则创建失败；
• 为进程分配资源，此处如果资源不足，则进程就会进入等待状态，以等待资源；
• 初始化PCB；
• 如果进程的调度队列能够接纳新进程，那就将进程插入到就绪队列，等待被调度运行。

2 终止进程

进程可以有3中终止方式：正常结束、异常结束以及外界干预。

终止进程的过程如下：

• 查找需要终止的进程的PCB；
• 如果处于执行状态，则立即终止该进程的执行，然后将CPU资源分配给其他进程。
• 如果其还有子进程，则应将其所有子进程终止；
• 将该进程所拥有的全部资源都归还给父进程或操作系统；
• 将其从PCB所在队列中删除；

3 阻塞进程

当进程需要等待某一事件完成时，它可以调用阻塞语句把自己阻塞。而一旦被阻塞等待，它只能由另一个进程唤醒。

阻塞进程的过程如下：

• 找到将要被阻塞进程标识号对应的PCB；
• 如果该进程为运行状态，则保护其现场，将其状态转为阻塞状态，停止运行；
• 将该PCB插入带阻塞队列中去

4 唤醒进程

进程有运行转变为阻塞状态是由于进程必须等待某一事件的完成，所以处于阻塞状态的进程是绝对不可能叫醒自己的。

如果某进程正在等在I/O事件，需要别的进程发消息给它，则只有当该进程所期待的事件出现时，才由发现者进程用唤醒语句叫醒它。

唤醒进程的过程如下：

• 在该时间的阻塞队列中找到相应进程的PCB；
• 将其从阻塞队列中移除，并置其状态为就绪状态；
• 把该PCB插入到就绪队列中，等待调度程序调度；

进程的阻塞和唤醒是一对功能相反的语句，如果某个进程调用了阻塞语句，则必有一个与之对应的唤醒语句。

进程的上下文切换

各个进程之间是共享CPU资源的，在不同的时候进程之间须要切换，让不同的进程可以再CPU执行，那么一个进程切换到另一个进程运行，称为进程的上下文切换。

CPU上下文切换

大多数操作系统都是多任务，通常支持大于CPU数量的任务同时运行。实际上，这些任务并不是同时运行的，只是因为系统在很短的时间内，让各个任务分别在CPU运行，于是就造成了同时运行的错觉。

任务是交给CPU运行的，那么在每个任务运行前，CPU需要知道任务从哪里加载，又从哪里开始运行。

所以，操作系统需要事先帮CPU设置好CPU寄存器和程序计数器。

CPU寄存器是CPU内部一个容量小，但是速度快的内存。程序计数器则是用来存储CPU正在执行的指令位置、或者即将执行的下一条指令位置。

所以说，CPU寄存器和程序计数是CPU在运行任何任务前，所必须依赖的环境，这些环境就叫做CPU上文。

既然知道了什么是CPU上下文，那理解CPU上下文切换就不难了。

CPU上下文切换就是先把前一个任务的CPU上下文（CPU寄存器和程序计数器）保存起来，然后加载新任务的上下文到这些寄存器和程序计数器，最后在跳转到程序计数器所指的新位置，运行新任务。

系统内核会存储保持下来的上下文信息，当次任务再次被分配给CPU运行时，CPU会重新加载这些上下文，这样就能保证任务原来的状态不受影响，让任务看起来还是连续运行。

任务，主要包含进程、线程和中断。所以，可以根据任务的不同，把CPU上下文切换分成：进程上下文切换、线程上下文切换和中断上下文切换。

进程的上下文切换

进程是由内核和调度的，所以进程的切换只能发生在内核态。

所以，进程的上下文切换不仅包含虚拟内存、栈、全局变量等用户空间的资源，还包括了内核堆栈、寄存器等内核空间的资源。

通常，会把交换的信息保存在进程的PCB，当要运行另外一个进程的时候，我们需要从这个进程的PCB取出上下文，然后恢复到CPU中，这使得这个进程可以继续执行，如下图所示：

 需要注意的是，进程的上下文开销是很关键的，我们希望它的开销越小越好，这样可以使得进程可以把更多时间花费在执行程序上，而不是耗费在上下文切换。

发生进程上下文切换有哪些场景？

• 为了保证所有进程可以得到公平调度，CPU时间被划分为一段段的时间片，这些时间片再被轮流分配给各个进程。这样，当某个进程的时间片耗尽了，进程就从运行状态变为就绪状态，系统从就绪队列选择另外一个进程运行；
• 进程在系统资源不足时，要等到资源满足后才可以运行，这个时候进程也会被挂起，并有系统调度其他进程运行。
• 当有优先级更高的进程运行时，为了保证高优先级进程的运行，当前进程会被挂起，由高优先级进程来运行；
• 发生硬件中断时，CPU上的进程会被中断挂起，转而执行内核中的中断服务程序。

线程

在早起的操作系统中都是以进程作为独立运行的基本单位，直到后面，计算机科学家又提出了更小的独立运行的基本单位，也就是线程。

什么是线程？

线程是进程当中的一条执行流程。

同一个进程内多个线程之间可以共享代码段、数据段、打开的文件等资源，但每个线程各自都有一套独立的寄存器和栈，这样可以确保线程的控制流是相对独立的。

线程的优缺点？

线程的优点：

• 一个进程中可以同时存在多个线程；
• 各个线程之间可以并发执行
• 各个线程之间可以共享地址空间和文件等资源。

线程的缺点：

• 当进程中的一个线程崩溃时，会 导致其所属的所有线程崩溃（C++，Java则不会这样）

举个例子，对于游戏的用户设计，则不应该使用多线程的方式，否则一个用户挂了，会影响其他同个进程的线程。

线程和进程的比较

线程和进程的比较如下：

• 进程是资源（包括内存、打开的文件）分配的单位，线程是CPU调度的单位；
• 进程拥有一个完整的资源平台，而线程只独享必不可少的资源，如寄存器和栈；
• 线程同样具有就绪、阻塞、执行三种基本状态，同样具有状态之间的转换关系；
• 线程能减少并发执行力的时间和空间开销。

对于，线程相比进程能减少开销，体现在：

• 线程的创建时间比进程快，因为进程在创建的过程中，还需要资源管理信息，比如内存管理信息，文件管理信息，而线程在创建的过程中，不会设计这些资源管理信息，而是共享它们；
• 线程的终止时间比进程快，因为线程释放的资源相比进程少很多；
• 同一个进程内的线程切换比晋升切换快，因为线程具有相同的地址空间（虚拟内存共享），这意味着同一个进程的线程都具有同一个页表，那么在切换的时候不需要切换页表。而对于进程之间的切换，切换的时候要把页表给切换掉，而页表的切换过程开销是比较大的；
• 由于同一个进程的个线程间共享内存和文件资源，那么在线程之间数据传递的时候，就不需要经过内核了，这就使得线程之间的数据交互效率更高了。

所以，不管是时间效率，还是空间效率线程比进程都要高。

线程的上下文切换

在前面我们知道了，线程与进程的最大区别在于：线程是调度的基本单位，而进程则是资源拥有的基本单位。

所以，所谓操作系统的任务调度，实际上的调度对象是线程，而进程知识给线程提供了虚拟内存、全局变量等资源。

对于线程和进程，我们可以这样理解：

• 当进程只有一个线程时，可以认为进程就等于线程；
• 当进程拥有多个线程时，这些线程会共享相同的虚拟内存和全局变量等资源，这些资源在上下文切换时是不需要修改的；

另外，线程也有自己的私有数据，比如栈和寄存器等，这些在上下文切换时也是需要保存的。

线程上下文切换的是什么？

• 当两个线程不是属于同一个进程，则切换的过程就跟进程上下文切换一样；
• 当两个线程是属于同一个进程，因为虚拟内存时共享的，所以在切换时，虚拟内存这些资源就保持不动，只需要切换线程的私有数据，寄存器等不共享的数据；

所以，线程的上下文切换相比进程，开箱要小很多。

线程的实现

主要有三种线程的实现方式：

• 用户线程：在用户空间实现的线程，不是由内核管理的线程，是由用户态的线程库来完成线程的管理；
• 内核线程：在内核中实现的线程，是由内核管理的线程。
• 轻量级进程：在内核中来了支持用户线程。

那么，这还需要考虑一个问题，用户线程和内核线程的对应同一个内核线程：

首先，第一种关系是多对一的关系，也就是多个用户线程对应同一个内核线程：

第二种是一对一的关系，也就是一个用户线程对应一个内核线程。

第三种是多对多的关系，也就是多个用户线程对应到多个内核线程。

用户线程如何理解？存在什么优势和缺陷？

用户线程是基于用户态的线程管理库来实现的，那么线程控制块（TCP）也是在库里面来实现的，对于操作系统而言是看不到这个TCP的，它只能看到整个进程的PCB。

所以，用户线程的整个线程管理和调度，操作系统是不直接参与的，而是由用户级线程来完成线程的管理，包括线程的创建、终止、同步和调度等。

用户级线程的模型，也就类似前面提到的多对一的关系，即多个用户线程对应同一个内核线程，如下图所示：

用户线程的优点：

• 每个进程都需要它私有的线程控制块（TCB）列表，用来跟踪记录它各个线程状态信息（PC/栈指针、寄存器），TCP有用户级线程函数来维护，可用于不支持线程技术的操作系统；
• 用户线程的切换也是有线程库函数来完成的，无需用户态与内核态的切换，所以速度特别快。

用户线程的缺点：

• 由于操作系统不参与线程的调度，如果一个线程发起了系统调用而阻塞，那进程所包含的用户线程都不能执行了。
• 当一个线程开始运行后，除非它主动地交出CPU的使用权，否则他所在的进程当中的其他线程无法运行，因为用户态的线程没法打断当前运行中的线程，它没有这个特权，只有操作系统才有，但是用户线程不是由操作系统管理的。
• 由于时间片分配给进程，故与其他进程相比，在多线程执行时，每个线程得到的时间片较少，执行会比较慢；

内核线程如何理解，存在什么优势和缺陷？

内核线程是由操作系统管理的，线程对应的TCB自然是放在操作系统里的，这样线程的创建、终止和管理都是由操作系统负责。

内核线程的模型，也就类似前面提到的一对一关系，即一个用户线程对应一个内核线程，如下图所示：

内核线程的优点：

• 在一个进程当中，如果某个内核线程发起系统调用而被阻塞，并不会影响其他内核线程的运行；
• 分配给线程，多线程的进程获得更多的CPU运行时间；

内核线程的优点：

• 在支持内核线程的操作系统中，由内核来维护进程和线程的上下文信息，如PCB和TCP；
• 线程的创建、终止和切换都是通过系统调用的方式来进行，因此对于系统来说，系统开销比较大；

最后的轻量级进程如何理解？

轻量级进程（Light-weight process, LWP）是内核支持的用户线程，一个进程可有一个或多个LWP，每个LWP是跟内核线程一对一映射的，也就是LWP都是有一个内核线程支持。

另外，LWP只能由内核管理并像普通进程一样被调度，Linux内核是支持LWP的典型例子。

在大多数系统中，LWP与普通进程的区别也在于它只有一个最小的执行上下文和调度程序所需的统计信息。一般来说。一个进程代表程序的一个实例，而LWP代表程序的执行程序，因为一个执行线程不像进程那样需要那么多状态信息，所以LWP也不带有这样的信息。

在LWP之上也是可以使用用户线程的，那么LWP与用户线程的对应关系就有三种：

1. 1:1，即一个LWP对应一个用户线程；
2. N:1，即一个LWP对应多个用户线程；
3. M:N，即多个LWP对应多个用户线程；

1:1模式：

一个线程对应到一个LWP在对应到一个内核线程，如上图的进程4，属于此模型。

优点：实现并行，当一个LWP阻塞，不会影响其他LWP；

缺点：每一个用户线程，就产生一个内核线程，创建线程的开销较大。

N:1模式

多个用户线程对应一个LWP在对应一个内核线程，如上图的进程2，线程管理是在用户空间完成的，次模式中用户的线程对操作系统不可见。

优点：用户线程要开几个都没问题，且上下文切换发生用户空间，切换的效率较高；

缺点：一个用户线程如果阻塞了，则整个进程都将会阻塞，另外在多核CPU中，是没战法充分利用CPU的。

M:N模式

根据前面的两个模式混搭在一起，就形成M:N模型，该模型提供了两级控制，首先多个用户线程对应到多个LWP，LWP再一一对应到内核线程，如上图的进程3.

优点:综合了前两种优点，大部分的线程上下文发生在用户空间，且多个线程有可以充分利用多核CPU的资源。

组合模式

如上图的进程5，此进程结合1:1模型和M:N模型。开发人员可以针对不同的应用特点调价内核线程的数目来达到物理并行性和逻辑并行性的最佳方案。

调度

进程都希望自己能够占用CPU进性工作，那么这涉及前面搜过的进程上下文切换。

一旦操作系统把进程切换到运行状态，也就意味中该进程占用着CPU在执行，但是当操作系统把进程切换到其他状态是，那就不能在CPU中执行了，于是操作系统会选择下一个要运行的进程。

选择一个进程这一功能是在操作系统中完成的，通常称为调度程序。

那到底生么时候调度进程，或以什么原则来调度进程呢?

调度时机

在进程的生命周期中，当进程从一个运行状态到另外一个状态变化的时候，其实会触发一次调度。

比如,以下状态的变化都会触发操作系统的调度：

• 从就绪态->运行态：当进程被创建时，会进入到就绪队列，操作系统会从就绪队列选择一个进程运行；
• 从运行态->阻塞态：当进程发生I/O事件而阻塞时，操作系统必须选择另外一个进程运行；
• 从运行态->结束态：当进程退出结束后，操作系统得从就绪对了选择另外一个进程运行；

因为，这些状态变化的时候，操作系统需要考虑是否要让新的进程给CPU运行，或者是否让当前进程从CPU上退出来而换另一个进程运行。

另外，如果硬件时钟提供某个频率的周期性中断，那么可以根据如何处理时钟中断，把调度算法分为两类：

• 非抢占式调度算法：挑选一个进程，然后让该进程运行知道被阻塞，或者直到该进程退出，才会调用另外一个进程，也就是说不会理会时钟中断这个事情。
• 抢占式调度算法：挑选一个进程，然后让该进程只运行某段时间，如果在该时段结束时，该进程仍然在运行时，则会把它挂起，接着调度程序从就绪队列挑选另外一个进程。这种抢占式调度处理，需要在时间间隔的末端发生时钟中断，以便把CPU控制返回给调度程序进行调度，也就是常说的时间片机制。

调度原则

原则一：如果运行的程序，发生了I/O事件的请求，那CPU使用率必然会很低，因此此时进程在阻塞等待硬盘的数据返回。这样的过程，势必会造成CPU突然的空闲。所以，为了提高CPU利用率，在这种发送I/O事件致使CPU空闲的情况下，调度程序需要从就绪队列中选择一个进程来运行。

原则二：有的程序执行某个任务花费的时间会比较长，如果这个程序一直占用着CPU，会造成系统吞吐量（CPU在单位时间内完成的进程数量）的降低。所以，要提高系统的吞吐率，调度程序要权衡长任务和短任务进程的运行完成数量。

原则三：从进程开始到结束的过程中，实际上是包含两个时间，分别是进程运行时间和进程等待时间，这两个时间总和就称为周转时间。进程的周转时间越小越好，如果进程的等待时间很长而运行时间很短，那周转时间就很长，这不是我们所期望的，调度程序应该避免这种情况发生。

原则四：处于就绪队列的进程，也不能等太久，当然希望这个等待时间越短越好，这样可以使得进程更快的在CPU中执行。所以，就绪队列中进程的等待时间也是调度程序所需要考虑的原则。

原则五：对于鼠标、键盘这种交互式比较强的应用，我们的当然希望它的响应时间越快越好，否则就会影响用户体验了。所以，对于交互式比较强的应用，响应时间也是调度程序需要考虑的原则。

针对上面的五种调度原则，总结成如下：

• CPU利用率：调度程序应确保CPU是始终匆忙的状态，这可提高CPU的利用率；
• 系统吞吐量：吞吐量表示的是单位时间内CPU完成进程的数量，长作业的进程会占用较长的CPU资源，因此会降低吞吐量，相反，短作业的进程会提升系统吞吐量；
• 周转时间：周转时间是进程运行+阻塞时间+等待时间的总和，一个进程的周转时间越小越好；
• 等待时间：这个等待时间不是失色状态的时间，而是进程处于就绪队列的时间，等待的时间越长，用户越不满意；
• 响应时间：用户提交请求到系统第一次产生响应所花费的时间，在交互式系统中，响应时间是权衡调度算法好坏的主要标准。

调度算法

不同的调度算法使用的场景也是不同的。

接下来，说说在单核CPU系统中常见的调度算法。

01先来先服务调度算法

最简单的一个调度算法，就是非抢占式的先来先服务算法。

每次从就绪队列选择最先进入队列的进程，然后一直运行，指导进程退出或被阻塞，才会继续从队列中选择第一个进程接着运行。

如果当一个长作业先运行了，那么后面的短作业等待的时间就会很长，不利于短作业。

02 最短作业优先调度算法

它会优先选择运行时间最短的进程来运行，这有助于提高系统的吞吐量。

这显然对长作业不利，很容易造成一种极端现象。

03 高响应比优先调度算法

高响应比优先调度算法主要是权衡了短作业和长作业，每次进程进程调度时，先计算响应比优先级，然后把响应比优先级最高的进程投入运行，响应比优先级的计算公式：

优先权=（等待时间+要求服务时间）/要求服务时间

由上述公式，可以得知：

• 如果两个进程的等待时间相同时，要去服务时间越短，响应比越高，这要短作业的进程容易被选中运行；
• 如果两个进程要求的服务时间相同时，等待时间越长，响应比越高，这就兼顾了长作业进程，因为进程的响应比可以随等待时间的增加而提高，当其等待时间足够长时，其响应比便可以升到很高，从而获得运行的机会；

04 时间片轮转调度算法

最古老、最简单、最公平且使用最广的算法就是时间片轮转调度算法。

每个进程被分配一个时间段，称为时间片，即允许该进程在该时间段中运行。

• 如果时间片用完，进程还在运行，那么将会把此进程从CPU释放出来，并把CPU分配给另外一个进程；
• 如果该进程在时间片结束前阻塞或结束，则CPU立即进程切换。

另外，时间片的长度就是一个很关键的点：

• 如果时间片设的太短会导致过多的进程上下文切换，降低了CPU效率；
• 如果也得太长有可能引起短作业进程的响应时间变长。

一般来说，时间片设为20ms~50ms 通常是一个比较合理的折中值。

05 最高优先级调度算法

对于多用户计算机系统就不同了，它们希望调度是由优先级的，即希望调度程序能从就绪队列中选择最高优先级的进程进行运行，be称为走高优先级调度算法。

进程的优先级可以分为，静态优先级和动态优先级：

• 静态优先级：创建进程时候，就已经确定了优先级了，然后整个运行时间优先级都不会变化；
• 动态优先级：根据进程的动态变化调整优先级，比如如果进程运行时间增加，则降低其优先级，如果进程等待时间增加，则提高其优先级，也就是随着时间的推移增加等待进程的优先级。

该算法也有两种处理优先级高的方法，非抢占式和抢占式：

• 非抢占式：当就绪队列中出现优先级高的进程，运行完当前进程，在选择优先级高的进程。
• 抢占式：当就绪队列中出现优先级高的进程，当前进程挂起，调度优先级高的进程运行。

但是依然有缺点，可能会导致优先级低的进程永远不会运行。

06 所及反馈队列调度算法

多级反馈队列调度算法是时间片轮转算法和最高优先级算法的综合和发展。

它是如何工作的呢？

• 设置了多个队列，赋予每个队列不同的优先级，每个队列优先级从高到低，同时优先级越高时间片越短；
• 新的进程会被放入到第一级队列的末尾，按先来先服务的原则排队等待被调度，如果在第一级队列规定的时间片没运行完，则将其转入第二级队列的末尾，以此类推，直至完成；
• 当较高优先级的队列为空秒了调度较低优先级的队列中的进程运行。如果进程运行时，有新进程进入较高优先级的队列，则停止当前运行的进程并将其移入到原队列末尾，接着让较高优先级的进程运行。

可以发现，对于短作业可能可以在第一级队列被处理完。对于长作业，如果在第一级队列处理不完，可以移入下次队列等待被执行，虽然等待的时间变长了，但是运行时间也变更长了，所以该算法很好的兼顾了长短作业，同时有较好的响应时间。