大学操作系统课程笔记

第一章 操作系统引论

---

1、什么是操作系统？

操作系统(Operating System,OS)是指控制和管理整个计算机系统的硬件和软件资源，并合理地组织调度计算机的工作和资源的分配，以提供给用户和其他软件方便的接口和环境，它是计算机系统中最基本的系统软件

2、操作系统的目标和作用

没有任何软件支持的计算机称为裸机。
在裸机上安装的操作系统，可以提供资源管理功能和方便用户的服务功能，将裸机改造成功能强，使用更方便的机器。通常把覆盖了软件的机器称为扩充机器，又称之为虚拟机

操作系统的目标与应用环境有关。
例如在查询系统中所用的OS，希望能提供良好的人-机交互性；
对于工业控制、武器控制以及多媒体环境下的OS，要求其具有实时性；
而对于微机上配置的OS，则更看重的是其使用的方便性

操作系统（工匠）对硬件机器（原料）的拓展

通过优秀工匠，这些简单的原料可以组织成房子、桌子……普通用户可直接使用工匠提供的房子、桌子等，而无需关心这些东西在底层是怎么组织起来工作

3、计算机系统层次结构

1. 假如自己组装电脑，如何最终实现和同学聊天？

1. 组装裸机
2. 安装Windows系统
3. 安装微信电脑版
4. 和同学聊天

转换为专业术语即：

裸机(硬件、CPU等)–>操作系统–>应用程序(软件)–>用户

2. 操作系统职能

1. 负责管理协调硬件、软件等计算机资源的工作
2. 为上层的应用程序、用户提供简单易用的服务
3. 操作系统是系统软件，不是硬件

3. 操作系统作为系统职能管理者

进程是一个程序的执行。执行前需要将该程序放到内存中，才可以被CPU处理。

提供的功能

1. 文件管理(从"我的电脑找到QQ")
2. 存储器管理(双击打开QQ.exe)
3. 处理机管理(QQ程序正常运行)
4. 设备管理(获取摄像头进行视频聊天)

4. 操作系统作为用户和计算机之间的接口

1. 命令接口：允许用户直接使用
2. 程序接口：允许用户通过程序间接使用
3. GUI：现代操作系统中最流行的图形用户接口(如在Window拖动图标完成操作)

三者统称为用户接口

命令接口(允许用户直接使用)

联机命令接口：用户说一句，系统做一句(如命令提示符中的操作)
脱机命令接口：用户说一堆，系统做一堆(如一些系统文件)

程序接口(允许用户通过程序间接使用)

由一组系统调用组成(程序接口==系统调用)
编程人员在程序中通过程序接口请求操作系统提供服务

图形用户接口(GUI)

采用图形方式显示的计算机操作用户界面
用户可以形象的是使用图形界面进行操作，不需要记忆复杂的命令、参数
例如：Windows操作系统删除文件，只需拖动到回收站即可

4、操作系统的基本特性

①并发 ②共享 ③虚拟 ④异步
并发和共享是两个最基本的特征，互为存在条件

并发

指两个或多个事件在同一时间间隔内发生。这些事件宏观上是同时发生的，但微观上是交替发生的。

并行(不要混淆)：指两个或多个事件在同一时刻同时发生。

一个单核处理机(CPU)同一时刻只能执行一个程序，因此操作系统会负责协调多个程序交替执行(这些程序微观上是交替执行的，但宏观上看起来就像在同时执行)事实上，操作系统就是伴随着“多道程序技术”而出现的。因此，操作系统和程序并发是一起诞生的。

共享

共享即资源共享，是指系统中的资源可供内存中多个并发执行的进程共同使用。

互斥共享

系统中的某些资源(临界资源)，虽然可以提供给多个进程使用，但一个时间段内只允许一个进程访间该资源。

例子：使用QQ和微信视频。同一时间段内摄像头只能分配给其中一个进程。

同时共享

系统中的某些资源，允许一个时间段内由多个进程“同时”对它们进行访问

例子：使用QQ发送文件A，同时使用微信发送文件B。
宏观上看，两边都在同时读取并发送文件，说明两个进程都在访问硬盘资源，从中读取数据。微观上看，两个进程是交替着访问硬盘的。

注意：所谓的“同时”往往是宏观上的，而在微观上，这些进程可能是交替地对该资源进行访问的(即分时共享)

虚拟

虚拟是指把一个物理上的实体变为若干个逻辑上的对应物。物理实体(前者)是实际存在的，而逻辑上对应物(后者)是用户感受到的。

问题1：为什么内存4G却能运行比4G大的内容？

答：这是虚拟存储器技术。实际只有4GB的内存，但在用户看来似乎远远大于4GB，这是虚拟技术中的“空分复用技术”（第三章介绍）

问题2：一个程序需要被分配CPU才能正常执行，那么为什么单核CPU的电脑中能同时运行这么多个程序呢？

答：这是虚拟处理器技术。虚拟技术中的“时分复用技术” 微观上处理机在各个微小的时间段内交替着为各个进程服务

显然，如果失去了并发性，则一个时间段内系统中只需运行一道程序，那么就失去了实现虚拟性的意义了。因此，没有并发性，就谈不上虚拟性

异步

异步是指在多道程序环境下，允许多个程序并发执行，但由于资源有限，进程的执行不是一贯到底时，而是走走停停，以不可预知的速度向前推进，这就是进程的异步性。

如果失去了并发性，则系统只能串行地处理各个进程，每个进程的执行会一贯到底，也就谈不上异步性了。

没有并发和共享，就谈不上虚拟和异步，因此并发和共享是操作系统的两个最基本的特征

5、操作系统的发展与分类

1. 人工操作方式

早期的操作方式是由程序员将事先已穿孔的纸带(或卡片)，装入纸带输入机(或卡片输入机)，再启动它们将纸带(或卡片)上的程序和数据输入计算机，然后启动计算机运行。仅当程序运行完毕并取走计算结果后，才允许下一个用户上机。

缺点

①用户独占全机，即一台计算机的全部资源由上机用户所独占
②CPU等待人工操作(慢)。当用户进行装带(卡)、卸带(卡)等人工操作时，CPU及内存等资源是空闲的。

2. 单道批处理系统

优点

缓解了一定程度的人机速度矛盾，资源利用率有所提升。

缺点

内存中仅能有一道程序运行，只有该程序运行结束之后才能调入下一道程序。CPU有大量的时间是在空闲等待I/O完成(比手动快一点，不过还是慢)。资源利用率依然很低。

3. 多道批处理系统

优点

多道程序并发执行，共享计算机资源。资源利用率大幅提升，CPU和其他资源保持“忙碌”状态，系统吞吐量增加。

缺点

用户响应时间长，没有人机交互功能(用户提交自己的作业之后就只能等待计算机处理完成，中间不能控制自己的作业执行)

4. 分时操作系统

计算机以时间片(如一个时间片50ms)为单位轮流为各个用户/作业服务，各个用户可通过终端与计算机进行交互。

优点

用户请求可以被即时响应，解决了人机交互问题。允许多个用户同时使用一台计算机，并且用户对计算机操作相互独立，感受不到别人的存在。

缺点

不能优先处理一些紧急任务。操作系统对各个用户/作业都是完全公平的，循环地为每个用户/作业服务一个时间片，不区分任务的紧急性

5. 实时操作系统

优点

能够优先响应一些紧急任务，某些紧急任务不需要时间片排队。
在实时操作系统的控制下，计算机系统接收到外部信号后及时进行处理，并且要在严格的时限内处理完事

硬实时操作系统：必须在绝对严格的规定时间内完成处理（如导弹控制系统）
软实时操作系统：能接受偶尔违反时间规定（如校园浇花系统）

6. 网络操作系统

网络操作系统是伴随着计算机网络的发展而诞生的，能把网络中各个计算机有机地结合起来，实现数据传送等功能，实现网络中各种资源的共享(如文件共享)和各台计算机之间的通信。 （如：Windows NT 就是一种典型的网络操作系统，网站服务器就可以使用)

7. 分布式操作系统

主要特点是分布性和并行性。系统中的各台计算机地位相同，任何工作都可以分布在这些计算机上，由它们并行、协同完成这个任务。

8. 个人操作系统

如Windows10，MacOs

6、OS运行机制和体系结构

1. 运行机制

指令是CPU能识别、执行的最基本命令

1.1 两种指令

①特权指令：不允许普通用户使用的指令（如内存清零指令）
②非特权指令：普通用户可以任意使用的指令（如加减法）

1.2 两种处理器状态

①用户态（目态）：此时CPU只能执行非特权指令
②核心态（管态）：此时特权指令、非特权指令都可以执行

程序状态字寄存器（PSW）中的某标志位来标识当前处理器处于什么状态。如0为用户态，1为核心态

CPU如何判断当前是否可以执行特权指令？
答：通过PSW进行判断。当处理器处于用户态时不能执行特权指令；当处于核心态时可以执行特权指令

1.3 两种程序

①内核程序：操作系统的内核程序是系统的管理者，既可以执行特权指令，也可以挠行非特权指令，运行在核心态。
②应用程序：为了保证系统能安全运行，普通应用程序只能执行非特权指令，运行在用户态

2. 操作系统内核

内核是计算机上配置的底层软件，是操作系统最基本、最核心的部分。
实现操作系统内核功能的程序就是内核程序。
不同操作系统对内核的划分可能不一样

1. 功能

①实现计时功能
②负责实现中断机制

内中断(内部异常)

• 陷阱(trap)：有意而为之的异常，如系统调用
• 故障(fault)：由错误条件引起的，可能被故障处理程序修复，如缺页中断
• 终止(abort)：不可恢复的致命错误造成的结果，终止处理程序不再将控制返回给引发终止的应用程序，如整数除0

外中断

• I/O中断请求
• 人工干预

2. 原语

原语的特点是执行期间不允许中断，只能一气呵成，具有原子性，这种不可被中断的操作即原子操作
比如阻塞态–>就绪态，若PCB修改时被中断了，就会发生错误，因此原语是很必要的
原语采用“关中断指令”和“开中断指令”实现。

原语是一种特殊的程序，处于操作系统最底层，是最接近硬件的部分
运行时间较短，调用频繁

当关中断命令开启时，中断指令无法发挥作用；同理可得开中断指令

---

第二章 进程的描述与控制

1. 前趋图

​ 前趋图(Precedence Graph)是指一个有向无循环图，可记为DAG(Directed Acyclic Graph)，用于描述进程之间执行的先后顺序，图中的每个结点可用来表示一个进程或程序段，乃至一条语句，结点间的有向边则表示两个结点之间存在的偏序(Partial Order)或前趋关系(Precedence Relation)。

• 进程(或程序)之间的前趋关系可用“→”来表示

• 如果进程Pi和Pj存在着前趋关系，可表示为(Pi，Pj)∈→，也可写成Pi→Pj，表示在Pj开始执行之前Pi 必须完成。此时称Pi是Pj的直接前趋，而称Pj是Pi的直接后继

• 在前趋图中，把没有前趋的结点称为初始结点(Initial Node)，把没有后继的结点称为终止结点(Final Node)。此外，每个结点还具有一个重量(Weight)，用于表示该结点所含有的程序量或程序的执行时间

2. 程序执行

一个应用程序由若干个程序段组成，在执行时，都需要按照某种先后次序

1. 程序顺序执行特征

① 顺序性：处理机严格地按照程序所规定的顺序执行，即每一操作必须在下一个操作开始之前结束
②封闭性：程序在封闭的环境下运行，即程序运行时独占全机资源，资源的状态(除初始状态外)只有本程序才能改变它，程序一旦开始执行，其执行结果不受外界因素影响；
③可再现性：只要程序执行时的环境和初始条件相同，当程序重复执行时，不论它是从头到尾不停顿地执行，还是“停停走走”地执行，都可获得相同的结果。程序顺序执行时的这种特性，为程序员检测和校正程序的错误带来了很大的方便。

2. 程序并发执行特征

​ 在引入了程序间的并发执行功能后，虽然提高了系统的吞吐量和资源利用率，但由于它们共享系统资源，以及它们为完成同一项任务而相互合作，致使在这些并发执行的程序之间必将形成相互制约的关系，由此会给程序并发执行带来新的特征。

①间断性：程序只有在自己的时间片内才执行，过程断断续续
②失去封闭性：资源已共享，自然失去封闭性
③不可再现性：比如两个程序A和B共享变量N，A做N=N+1操作，B做print（N）并清零操作，若A和B以不同速度运行，则N的值会发生变化

由此，决定了通常的程序是不能参与并发执行的

3. 进程

1. 进程的描述

程序段、相关数据段、PCB，简称进程(进程实体)
创建进程，实质上是创建进程实体中的PCB；而撤销进程，实质上是撤销进程实体中的PCB。

PCB是程序存在的唯一标志！

• 进程是程序的一次执行过程
• 进程是一个程序及其数据在处理机上顺序执行时所发生的活动
• 进程是具有独立功能的程序在数据集合上运行的过程，它是系统进行资源分配和调度的一个独立单位

1.1. 进程组成

操作系统所需的数据都在PCB中

• 程序段：存放执行代码

• 数据段：存放运行过程中处理的各种数据

1.2. 进程组织方式

进程的组成讨论的是一个进程内部由哪些部分构成的问题
进程的组织讨论的是多个进程之间的组织方式问题

1.3 进程特征

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

1.4 进程基本状态

进程是程序的一次执行。在这个执行过程中，有时进程正在被CPU处理，有时又需要等待CPU服务。可见，进程的状态是会有各种变化。为了方便对各个进程的管理，操作系统需要将进程合理地划分为几种状态。

其中运行态、就绪态、阻塞态是进程的三种基本状态

1.5 挂起操作

挂起（暂停执行）操作的引入，是基于系统和用户的如下需要：
①终端用户的需要 ②父进程请求 ③负荷调节的需要 ④操作系统的需要

挂起和阻塞的区别

挂起：一般是主动(用户需要)的，由系统或程序发出，大部分挂起到辅存中去。(释放CPU，可能释放内存，放在外存)
阻塞：一般是被动(进程主动发起阻塞，不过是被迫主动【触发事件】)的，在抢占资源中得不到资源，被动的挂起在内存，等待某种资源或信号量（即有了资源）将他唤醒。(释放CPU，不释放内存)

在引入挂起原语Suspend和激活原语Active后，在它们的作用下，进程将发生以下几种状态的转换：

2. 进程控制

进程控制是进程管理中最基本的功能，主要包括创建新进程、终止已完成的进程、将因发生异常情况而无法继续运行的进程置于阻塞状态、负责进程运行中的状态转换等功能（总的来说就是实现进程状态转换）
进程控制一般是由OS的内核中的原语来实现的。

3. 进程创建

在OS中，允许一个进程创建另一个进程，通常把创建进程的进程称为父进程，而把被创建的进程称为子进程

过程

在系统中每当出现了创建新进程的请求后，OS便调用进程创建原语Create按下述步骤创建一个新进程：

1. 申请空白PCB：为新进程申请获得唯一的数字标识符，并从PCB集合中索取一个空白PCB。
2. 为新进程分配其运行所需的资源：包括各种物理和逻辑资源，如内存、文件、I/O设备和CPU时间等。从操作系统或者从父进程中获取。
3. 初始化进程控制块(PCB)。
   ①初始化标志信息：将系统分配的标识符和父进程的标识符填入新PCB中。
   ②初始化处理机状态信息：使程序计数器指向程序端口地址，使栈指针指向栈顶。
   ③初始化处理机控制信息：将进程设置为就绪状态或静止就绪状态。
   ④设置进程的默认优先级。
4. 如果进程就绪队列能够接纳新进程，便将新进程插入就绪队列。

4. 进程的终止

1. 正常结束：进程任务已经完成，正常退出。用一个HALT中断通知系统进程结束。
2. 异常结束：指进程在运行时发生了某种异常事件而退出
   ①越界错：程序访问了越界数据。
   ②保护错：试图访问一个不允许的资源或文件。
   ③非法指令：试图执行一条不存在的指令（数据当成指令）
   ④特权指令错：试图执行一条OS指令。
   ⑤运行超时
   ⑥等待超时
   ⑦算术运算错
   ⑧I/O故障
3. 外界干预 ：应外界请求而终止。
   ①操作员或操作系统干预
   ②父进程请求结束
   ③因父进程终止，所有子孙进程也要终止。

过程

如果系统中发生了要求终止进程的某事件，OS便调用进程终止原语，按下述过程去终止指定的进程：

1. 根据被终止进程的标识符，从PCB集合中检索出该进程的PCB，从中读出该进程的状态；
2. 若被终止进程正处于执行状态，应立即终止该进程的执行，并置调度标志为真，用于指示该进程被终止后应重新进行调度；
3. 若该进程还有子孙进程，还应将其所有子孙进程也都予以终止，以防它们成为不可控的进程；
4. 将被终止进程所拥有的全部资源或者归还给其父进程，或者归还给系统；
5. 将被终止进程(PCB)从所在队列(或链表)中移出，等待其它程序来搜集信息。

5. 进程的阻塞与唤醒

5.1 进程阻塞过程

正在执行的进程，如果发生了上述某事件，进程便通过调用阻塞原语block将自己阻塞。

进入block过程后，由于该进程还处于执行状态，所以应先立即停止执行，把进程控制块中的现行状态由“执行”改为阻塞，并将PCB插入阻塞队列。如果系统中设置了因不同事件而阻塞的多个阻塞队列，则应将本进程插入到具有相同事件的阻塞队列。

最后，转调度程序进行重新调度，将处理机分配给另一就绪进程，并进行切换。

5.2 进程唤醒过程

当被阻塞进程所期待的事件发生时，比如它所启动的I/O操作已完成，或其所期待的数据已经到达，则由有关进程(比如提供数据的进程)调用唤醒原语wakeup，将等待该事件的进程唤醒。

wakeup执行的过程是：首先把被阻塞的进程从等待该事件的阻塞队列中移出，将其PCB中的现行状态由阻塞改为就绪，然后再将该PCB插入到就绪队列中。

6. 进程的挂起与激活

6.1 进程的挂起

当系统中出现了引起进程挂起的事件时，OS将利用挂起原语suspend将指定进程或处于阻塞状态 的进程挂起。

suspend执行的过程是：首先检查被挂起进程的状态，若处于活动就绪状态，便将其改为静止就绪；对于活动阻塞状态的进程，则将之改为静止阻塞；为了方便用户或父进程考察该进程的运行情况，而把该进程的PCB复制到某指定的内存区域；最后，若被挂起的进程正在执行，则转向调度程序重新调度。

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

6.2 进程的激活

当系统中出现了激活进程的事件时，OS将利用激活原语active，将指定进程激活。

active执行的过程是：首先将进程从外存调入内存，检查该进程的现行状态，若是静止就绪，便将之改为活动就绪；若为静止阻塞，便将之改为活动阻塞。假如采用的是抢占调度策略，则每当有静止就绪进程被激活而插入就绪队列时，便应检查是否要进行重新调度，即由调度程序将被激活的进程与当前进程两者的优先级进行比较，如果被激活进程的优先级低，就不必重新调度；否则，立即剥夺当前进程的运行，把处理机分配给刚刚被激活的进程。

7. 进程通信

即进程之间的信息交换
进程是分配系统资源的单位（包括内存地址空间)，因此各进程拥有的内存地址空间相互独立。

但进程之间的信息交换又是必须实现的，怎么办呢？为了保证进程间的安全通信，操作系统提供了一些方法

7.1 共享存储

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

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

7.2 管道通信

“管道”是指用于连接读写进程的一个共享文件，又名pipe文件。其实就是在内存中开辟一个大小固定的缓冲区

7.3 消息传递

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

8. 进程同步

同步机制是对多个相关进程在执行次序上进行协调，使多个进程共享系统资源，互相合作，使其有再现性。

间接相互制约关系：在访问临界资源，如打印机、磁带机等，需要系统协调。
直接相互制约关系：主要指多个进程处理同一个数据，必须具有先后顺序。但是由于进程自身无法把控运行时间顺序，即产生进程的异步性(即进程执行不是一贯到底，而是走走停停)。

读进程和写进程并发地运行，由于并发必然导致异步性，因此“写数据”和“读数据”两个操作执行的先后顺序是不确定的。而实际应用中，又必须按照“写数据→读数据”的顺序来执行的。如何解决这种异步问题，就是“进程同步”所讨论的内容。

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

两种资源共享方式

同时共享方式：系统中的某些资源，一个时间段内允许多个进程访问该资源

互斥共享方式：系统中的某些资源，虽然可以提供给多个进程使用，但一个时间段内只允许一个进程访问该资源（临界资源）
由于临界资源一个时间段内只允许一个进程访问，因此在进程访问临界资源时，需要让其他进程知道这个临界资源已被使用，即上锁

为了实现对临界资源的互斥访问，同时保证系统整体性能，需要遵循以下原则：

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

9. 进程互斥的实现方法

9.1 硬件实现方法

①中断屏蔽方法

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

优点：简单、高效

缺点：①不适用于多处理机（A处理机调用中断并不会影响到B处理机，因此多核达不到完全中断效果）；
②只适用于操作系统内核进程，不适用于用户进程（因为开/关中断指令只能运行在内核态，这组指 令如果能让用户随意使用会很危险）

②TestAndSetLock指令

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

C语言实现逻辑如下：

//布尔型共享变量lock表示当前临界区是否被加锁
//true表示已经加锁，false表示未加锁
bool TestAndSet(bool *lock){
    bool old=*lock; //old用来存放原来的值
    *lock=true;  //如果之前已加锁，则阻止其访问临界区；若之前未加锁，则return old让其通过     *lock=true;   //一次后再阻止其他进程对临界资源访问，因为此时已被占用
    return old; //返回lock原来的值
}
//使用TSL实现互斥的算法逻辑
while(TestAndSet(&lock));//判断是否放行,lock为true不放行
临界区代码……
lock=false;  //临界区已经访问完，可以放行
剩余区代码……

③Swap指令

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

逻辑上来看Swap和TSL并无太大区别，都是先记录下此时临界区是否已经被上锁（记录在old变量上)，检查old决定是否放行，放行后锁上，执行结束后解锁lock=false;

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

缺点：不满足“让权等待”原则（没有让处理机空出来），暂时无法进入临界区的进程会占用CPU并循环执行TSL指令(while指令)，从而导致“忙等”。

2.10.2 信号量机制

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

• 一对原语：wait(S)原语和signal(S)原语，可以把原语理解为我们自己写的函数，函数名分别为wait和signal，括号里的信号量S其实就是函数调用时传入的一个参数
• wait、signal原语常简称为P、V操作（来自荷兰语proberen和 verhogen〉。因此，做题的时候常把wait(S)、signal(S)两个操作分别写为P(S)、V(S)
• 用户进程可以通过使用操作系统提供的一对原语来对信号量进行操作，从而很方便的实现了进程互斥、进程同步。

①整型信号量

C语言逻辑：

int S-1;  //初始化整型信号量S，表示当前系统中可用的打印机资源数

void wait(int S){  //wait原语，相当于“进入区”
    while(S<=0);   //如果资源数不够，就一直循环等待
    S=S-1；   //如果资源数够用，就占用一个资源
}

void signal(int S){ //singal原语，相当于“退出区”
    S=S+1;   //使用完资源后，在退出区释放资源
}
进程P:
……
wait(S);  //进入去，申请资源
使用打印机资源……  //临界区，访问资源
signal(S); //退出区，释放资源

存在的问题：不满足“让权等待”原则，会发生“忙等”（一直占用CPU）。
wait(s)和signal(s)是原子操作（最基本、最小的、中间不允许插入任何中断的操作。要执行就要执行完），只要信号量s≤0就不断测试，不满足让权等待。

②记录型信号量

C语言逻辑：

//记录型信号量的定义
typedef struct{
    int value;  //空闲资源数，<=0说明没有空闲资源
    struct process *L;  //等待队列
}semaphroe
//某进程需要使用资源时，通过wait原语申请
void wait(semaphore S){
    S.value--;  //申请使用，资源数减1
    if(S.value<0){ //说明当前CPU资源不够
        block(S.L); //将进程放入阻塞队列，等待适当机会唤醒
    }
}
//进程使用完资源后，通过signal原语释放
void signal(semaphore S){
    S.value++;  //已使用完，资源数加1
    if(S.value<=0){ //说明队列中有进程在等待，不应该空闲
        wakeup(S.L); //由阻塞态变就绪态，调用wait
    }
}

进程会调用block原语进行自我阻塞（当前运行的进程从运行态->阻塞态），主动放弃处理机，并插入该类资源的等待队列S.L中。可见，该机制遵循了“让权等待”原则，不会出现“忙等”现象。

★实现进程互斥及前驱关系

/*信号量机制实现互斥*/
semaphore mutex=1;  //初始化互斥信号量，对不同的临界资源需要设置不同的互斥信号量
p1(){
    ...
        p(mutex);  //检测到mutex==1，允许进入同时加锁,mutex=0
    临界区代码段... //此时mutex==0
        V(mutex);  //使用临界资源后需要解锁，令metux=1，允许其他进程访问
    ...
}

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

---

前驱关系问题本质上是更复杂的同步关系问题

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

①要为每一对前驱关系各设置一个同步变量(a、b…)

②"前操作"之后对相应的同步变量执行V操作

③"后操作"之前对相应的同步变量执行Р操作

将a、b…设置为0，是为了展示同步性，由于当前资源为0，因此需要等上一级释放资源后下一级才能使用，由此保证了同步性。要先有资源才能使用，因此P操作的上边一定是V操作

1、生产者消费者问题

①系统中有一组生产者进程和一组消费者进程，生产者进程每次生产一个产品放入缓冲区，消费者进程每次从缓冲区中取出一个产品并使用。(注:这里的“产品”理解为某种数据)
生产者、消费者共享一个初始为空、大小为n的缓冲区。
②只有缓冲区没满时，生产者才能把产品放入缓冲区，否则必须等待
(当缓冲区满时，生产者需要等待消费者取走产品才能继续操作，有顺序，所以是同步关系)
③只有缓冲区不空时，消费者才能从中取出产品，否则必须等待(同理也是同步关系)。
④缓冲区是临界资源，各进程必须互斥地访问

PV操作题目分析步骤:

1. 关系分析。找出题目中描述的各个进程，分析它们之间的同步、互斥关系。
2. 整理思路。根据各进程的操作流程确定P、V操作的大致顺序。
3. 设置信号量。设置需要的信号量，并根据题目条件确定信号量初值。(互斥信号量初值一般为1，同步信号量的初始值要看对应资源的初始值是多少)

semaphore mutex=1; //互斥信号量，实现对缓冲区的互斥访问
semphore empty=n;  //同步信号量，表示空闲缓冲区的数量
semphore full=0; //同步信号了，表示产品的数量，也叫非空缓冲区的数量

producer(){
    while(1){
        生产一个产品;
        P(empty); //消耗一个空闲缓冲区
        P(mutex)； //准备进入互斥，通过后禁止其他进程访问
            把产品放入缓冲区;
        V(mutex); //mutex=1，资源使用完毕，允许其他进程访问
        V(full); //经过生产，产品+1
        把产品放入缓冲区;
    }
}
consumer(){
    while(1){
        P(full);  //消耗一个产品(非缓冲区)
        P(mutex); //准备进入互斥，通过后禁止其他进程访问
        从缓冲区取出一个产品;
        V(mutex);  //解锁
        V(empty); //增加一个空闲缓冲区
    }
}

能否改变相邻P操作顺序？(先执行P(mutex)再执行P(empty/full))

答：不能。若先执行P(mutex)，则会进入下一步并锁程序，但若此时是满的，则p(empty)无法执行(空时同理p(full))，即会卡在此处，一直占用临界资源无法释放，后续进程也就无法对其进行调用，从而造成混乱。

2、读者写者问题

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

为什么读进程可以并发，写进程一次却只允许一个？
答：因为读数据后不会将数据清空，读与读之间互不影响，因此可以并发；而写与写如果同时发生，后者写的内容会将前者覆盖，从而造成混乱；写和读同时进行时，可能造成读写内容不一致，造成混乱。

关系：写读互斥、写写互斥、读读不互斥

semaphroe rw=1;  //用于实现对文件的互斥访问
int count=0;  //记录当前有几个读进程在访问文件
semaphore mutex=0;  //用于保证对count变量的互斥访问
semaphore w=1;  //用于实现相对"写优先"

writer(){
    while(1){
        P(w);  //阻止读进程进入
        P(rw);  //互斥访问临界资源
        写文件...
        V(rw);
        V(w);
    }
}
reader(){
    while(1){
        P(w); //配合写进程，防止写进程饥饿
        P(mutex); //一次只允许一个读进程进行count操作。防止混乱
        if(count==0)
            P(rw); //加锁，此时写进程无法访问
        count++;
        V(mutex);
        V(w);
        读文件...
        P(mutex); //防止读进程结束的count--同时进行，从而造成V(mutex)无法进行
        count--;
        if(count==0)
            V(rw);
        V(mutex);
    }
}

读者①–>读者②–>写者③–>读者④
答：①进入reader()，P(w)加锁，P(mutex)加锁(在释放前其他读进程无法进入)，此时count==0，所以P(rw)加锁(读写互斥)，count++后为1表示此时有一个元素在访问文件，++操作结束后V(mutex)、V(w)解锁，进入读文件……此时还没有释放P(rw)。
②进入reader()，由于P(w)和P(mutex)都解锁，因此可直接进入并加锁，同时因为count为1，所以不会进入P(rw)，因此不会被没有释放P(rw)而影响到，可以正常进行，count++后为2，解锁，进入读文件……假设②速度比①快，进入P(mutex)加锁，使进行count--时只有一个读进程在操作，避免混乱，执行后count为1，不满足解锁rw条件，因此②将资源归还后P(rw)依旧没有被释放，即依然有读进程在执行，写进程无法进入
③写文件进入P(w)并为其加锁，P(rw)会因为读进程没有释放而无法进入，因此需要等读进程结束后释放出资源才能继续往下执行，从而实现读写互斥。假设此时前边的读进程都已释放，读进程进入写文件，P(rw)加锁……
④在P(w)处无法进入，因为③为其加锁且还未释放，必须等③释放后才可进入，从而实现进程"先来先服务"原则，假设③执行完毕，则④变成一个单独的读进程，正常加锁解锁即可。

3、哲学家吃饭问题

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

思路分析：
首先要防止死锁发生，即每人拿起一根筷子
方法①：最多允许4个哲学家同时进餐，则最少有一个哲学家是可以吃饭的(原先每人一根正好分配，现在有一个人不拿筷子，因此肯定有一个人有两根筷子)
方法②：要求奇数号吃饭先拿起左边筷子；偶数号吃饭先拿起右边筷子，这样当相邻两位哲学家想吃饭时，一位会成功，另一位则被阻塞，避免了占有一只筷子后等待另一只筷子的情况。
方法③：仅当左右都有筷子时才允许他抓起筷子。

semaphore chopstick[5]={1,1,1,1,1};  //初始筷子状态
semaphore mutex=1;  //互斥取筷子
Pi(){
    while(1){
        P(mutex); //互斥加锁
        P(chopstick[i]); //拿左边
        P(chopstick[(i+1)%5]); //拿右边
        V(mutex);  //拿完筷子解锁
        吃饭...
        V(chopstick[i]);  //吃完放左边筷子
        V(chopstick[(i+1)%5]); //放右边
        哲学家继续思考...
    }
}

3. 线程

大扫除可以看作是一个大作业；
拖地、擦窗户、扫地是子作业，即程序，当它们执行时变为进程；
如擦窗户需要准备水、抹布等资源，然后需要有人去擦，这就是两个进程；
在准备水、抹布等资源时，可以另一个人去提水、一个人去洗抹布，这就是两个线程；
一个进程至少包含一个线程，线程之间相互独立，线程无法脱离进程而存在
多个线程共享进程内存，线程是一个基本的CPU执行单元，也是程序执行流的最小单位

引入线程之后，不仅是进程之间可以并发，进程内的各线程之间也可以并发，从而进一步提升了系统的并发度，使得一个进程内也可以并发处理各种任务（如QQ视频、文字聊天、传文件）。引入线程后，进程只作为资源分配的基本单位，线程是资源调度的基本单位；由于线程间并发，因此同一进程内的线程切换不需要切换进程环境，系统开销小。

3.1 属性

①线程是处理机调度的单位
②多CPU计算机中，各个线程可占用不同的CPU
③每个线程都有一个线程ID、线程控制块TCB
④线程也有就绪、阻塞、运行三种状态
⑤线程几乎不拥有系统资源
⑥同一进程的不同线程间共享进程资源
⑦由于共享内存地址空间，同一进程中的线程通信无需系统干预
⑧同一进程的线程切换，不会引起进程切换
⑨不同进程中的线程切换，会引起进程切换
⑩切换同进程的线程，系统开销很小

3.2 实现方式

线程是程序中一个单一的顺序控制流程。
在单个程序中同时运行多个线程完成不同的工作，称为多线程。
将线程和多线程同时放进一个指令集合称为线程库。

3.2.1 用户级线程

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

“用户级线程”就是“从用户视角看能看到的线程”

3.2.2 内核级线程

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

“内核级线程”就是“从操作系统内核视角看能看到的线程”

3.3 多线程模型

在同时支持用户级线程和内核级线程的系统中，由几个用户级线程映射到几个内核级线程的问题引出了“多线程模型”问题

3.3.1 多对一模型

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

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

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

3.3.2 一对一模型

一个用户级线程映射到一个内核级线程。每个用户进程有与用户级线程数量的内核级线程。

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

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

3.3.3 多对多模型

n用户及线程映射到m个内核级线程(n>= m）。每个用户进程对应m个内核级线程。

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

---

第三章 处理机调度与死锁

1、 作业

作业与进程的区别？
答：作业是用户向计算机提交的任务实体，而进程则是完成用户任务的执行实体，是向操作系统申请分配资源的基本单位。一个作业可以由多个进程组成，且一个作业至少由一个进程组成。作业的概念主要用在批处理系统中，而进程的概念则用在所有的多道程序系统中

作业：用户在一次计算过程中或一次事务处理过程中要求计算机系统所做的工作的集合。

执行过程看作是任务

作业步：一个作业分成若干个顺序处理的作业单位，执行过程看作是进程，子作业步看作是线程

1.1 作业控制块

为了管理和调度作业，在多道批处理系统中，为每个作业设置了一个作业控制块JCB，它是作业在系统中存在的标志，其中保存了系统对作业进行管理和调度所需的全部信息。
作业进入系统时，由“作业注册”建立一个作业控制块JCB，在根据作业类型，放入对应的就绪队列

1.2 作业运行三种状态

作业从进入系统到运行结束，通常需要经历收容、运行和完成三个阶段。相应的作业也就有“后备状态"，"运行状态”和“完成状态”。

• 收容阶段(后备状态)：操作员把用户提交的作业通过某种输入方式或SPOOLING系统输入到硬盘上，然后为该作业建立JCB，并把它放入作业后备队列中。
• 运行阶段(运行状态)：作业被作业调度选中后，为他分配必要的资源和建立进程，并将它放入就绪队列，直到运行结束。
• 完成阶段(完成状态)：作业完成或异常终止结束阶段，系统回收作业所占用的资源。

$\Delta$假脱机技术SPOOLING

什么称为"脱机"技术？
答：批处理中脱离主机控制进行的输入/输出操作(用磁带完成)。在外围控制机的控制下，慢速输入设备(如打孔编码)的数据先被输入到更快速的磁带上。之后主机可以从快速的磁带上读入数据，从而缓解速度矛盾

引入脱机技术后，缓解了CPU与慢速I/O设备的速度矛盾。另一方面，即使CPU在忙碌，也可以提前将数据输入到磁带；即使慢速的输出设备正在忙碌，也可以提前将数据输出到磁带。

什么是假脱机技术？
答：顾名思义，和脱机技术相比并不是真正的脱机，但能展现出脱机的效果

• 在磁盘中开辟出两个存储区域：输入井和输出井
  • 输入井模拟脱机输入时的磁带，用于收容I/O设备输入的数据
  • 输出井模拟脱机输出时的磁带，用于收容用户进程输出的数据
• 输入进程模拟脱机输入时的外围控制机；输出进程模拟脱机输出时的外围控制机
• 输入缓冲区和输出缓冲区是在内存中的缓存区
• 在输入进程的控制下，"输入缓冲区"用于暂存从输入设备输入的数据，之后再转存到输入井中；在输出进程的控制下，"输出缓冲区"用于暂存从输出井输出的数据，之后再传送到输出设备上；

共享打印机

打印机是"独占式设备"，但是可以用SPOOLING技术改造成"共享设备"

当多个用户进程提出打印的请求时，系统会答应它们的请求，但是并不是真正将打印机分配给他们，而是由假脱机管理进程为每个进程几件事

①在磁盘输出井中为进程申请一个空闲缓冲区，将要打印的数据送入其中
②输出井为用户进程申请一张空白的打印请求表，并将用户的打印请求填入表中，再将表挂到假脱机队列上
③当打印机空闲时，输出进程会从文件队列的队头取出一张打印请求表，并根据表中的请求将要打印的数据从输出井传送到输出缓冲区，再输出到打印机进行打印，依次完成所有打印任务

2、处理机调度

​ 当有一堆任务要处理，但由于资源有限，这些事情没法同时处理。这就需要确定某种规则来决定处理这些任务的顺序，这就是“调度”研究的问题。
在多道程序系统中，进程的数量往往是多于处理机的个数的，这样不可能同时并行地处理各个进程。处理机调度，就是从就绪队列中按照一定的算法选择一个进程并将处理机分配给它运行，以实现进程的并发执行

2.1 三个层次

名字	要做什么	调度发生位置	发生频率	对进程状态的影响
高级调度(作业调度)	按照某种规则，从后备队列中选择合适的作业将其调入内存，并为其创建进程	外存->内存(面向作业)	最低	无->创建态->就绪态
中级调度(内存调度)	按照某种规则，从挂起队列中选择合适的进程将其数据调回内存	外存->内存(面向进程)	中等	挂起态->就绪态(阻塞挂起->阻塞态)
低级调度(进程调度)	按照某种规则，从就绪队列中选择一个进程为其分配处理机	内存->CPU	最高	就绪态->运行态

2.2 进程调度与切换时机

• 当前运行的进程主动放弃处理机
  1. 进程正常终止
  2. 运行过程中发生异常而中止
  3. 进程主动请求阻塞(如等待I/O)
• 当前运行的进程被动放弃处理机
  1. 分给进程的时间片用完
  2. 有更紧急的事需要处理(如I/O中断)
  3. 有更高优先级的进程进入就绪队列
• 不能进行进程调度切换的情况
  1. 在处理中断的过程中。中断处理过程复杂，与硬件密切相关，很难做到在中断处理过程中进行进程切换
  2. 进程在操作系统内核程序临界区(如访问就绪队列，随意切换会混乱)中；但普通临界区访问的临界资源不会直接影响操作系统内核的管理工作，所以普通临界区可以进行进程调度和切换，比如在打印机打印完成之前，进程一直处于临界区内，临界资源不会解锁。但打印机又是慢速设备，此时如果一直不允许进程调度的话就会导致CPU一直空闲。
  3. 在原子操作过程中(原语)。原子操作不可中断，要一气呵成(如之前讲过的修改PCB中进程状态标志，并把PCB放到相应队列)

2.3 进程调度方式

非剥夺调度方式：只允许进程主动放弃处理机。在运行过程中即便有更紧迫的任务到达，当前进程依然会继续使用处理机，直到该进程终止或主动要求进入阻塞态。
分析：实现简单，系统开销小但是无法及时处理紧急任务，适合于早期的批处理系统

剥夺调度方式：当一个进程正在处理机上执行时，如果有一个更重要或更紧迫的进程需要使用处理机，则立即暂停正在执行的进程，将处理机分配给更重要紧迫的那个进程
分析：可以优先处理更紧急的进程，也可以实现让各进程按时间片轮流执行的功能(通过时钟中断)。适合于分时操作系统、实时操作系统

"狭义的进程调度"与"进程切换"的区别？
答："狭义的进程调度"指的是从就绪队列中选中一个要运行的进程；进程切换指一个进程让出处理机，由另一个进程占用处理机的过程。
"广义的进程调度"包括选择一个进程和进程切换两个步骤

进程切换主要完成以下内容：

• 对原来运行进程各种数据的保存
• 对新的进程各种数据的恢复
• 注意：进程切换是有代价的，因此如果过于频繁进行程序调度、切换，必然会使整个系统的效率降低，让系统大部分时间都花在进程切换上，而真正用于执行进程的时间减少

3、调度算法

3.1 评价指标

①CPU利用率

指CPU"忙碌"的时间占总时间的比例

$$CPU利用率=\frac{忙碌的时间}{总时间}$$

②系统吞吐量

单位时间内完成作业的数量

$$系统吞吐量=\frac{总共完成多少道作业}{总共花多少时间}$$

③周转时间

指从作业被提交给系统开始，到作业完成为止的时间间隔
包括四个部分：
①作业在外存后备队列上等待作业调度（高级调度）的时间；
②进程在就绪队列上等待进程调度（低级调度）的时间；
③进程在CPU上执行的时间；
④进程等待I/O操作 完成的时间。
后三项在一个作业的整个处理过程中，可能发生多次

$$\begin{gathered} 周转时间=作业完成时间-作业提交时间 \\ 平均周转时间=\frac{各作业周转时间之和}{作业数} \\ 带权周转时间=\frac{作业周转时间}{作业实际运行的时间}=\frac{作业完成时间-作业提交时间}{作业实际运行时间} \\ 平均带权周转时间=\frac{各作业带权周转时间之和}{作业数} \end{gathered}$$

④等待时间

计算机的用户希望自己的作业尽可能少的处理机等待时间，指进程/作业处于等待处理机状态时间之和，等待时间越长，用户满意度越低。

⑤响应时间

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

3.2 调度算法

3.2.1 先来先服务(FCFS)

• 算法思想：类似于排队买东西
• 算法规则：按照作业/进程到达先后顺序进行服务
• 用于作业/进程调度：用于作业调度时，考虑的是哪个作业先到后备队列；用于进程调度时，考虑的是哪个进程先到就绪队列
• 是否可抢占：否
• 是否导致饥饿：不会
• 优点：公平，算法实现简单
• 缺点：排在长作业(进程)后面的短作业需要等待很长时间，带权周转时间很大，对短作业来说用户体验不好。即对长作业有利，对短作业不利

3.2.2 短作业优先(SJF)

• 算法思想：追求最少的平均等待时间，最少的平均周转时间，最少的平均带权周转时间
• 算法规则：**当前队列中(正在运行的不算)**最短的作业/进程优先得到服务(所谓"最短"，指要求服务时间最短)
• 用于作业/进程调度：可用于作业调度，也可用于进程调度。用于进程调度时称为"短进程优先算法(SPF)"
• 是否可抢占：否
• 是否导致饥饿：会。如果源源不断有短作业/进程到来，可能使长作业/进程长时间得不到服务，产生"饥饿"。若一直得不到服务则"饿死"
• 优点："最短的"平均等待时间、平均周转时间
• 缺点：不公平。对短作业有利，对长作业不利。可能产生饥饿现象。另外，作业/进程的运行时间是由用户提供的，并不一定真实，不一定能做到真正的短作业优先

3.2.3 高响应比优先(HRRN)

$响应比=\frac{等待时间+要求服务时间}{要求服务时间}$

• 算法思想：要综合考虑作业/进程的等待时间和要求服务时间
• 算法规则：在每次调度时先计算各个作业/进程的响应比，选择响应比最高的作业/进程为其服务。
• 用于作业/进程调度：可用于作业调度，也可用于进程调度
• 是否可抢占：否，但是有抢占版本最短剩余时间算法(SRTN)，其算法思想是对所有进程包括正在运行的进程进行比较时间，哪个短就切换到哪个运行，并将当前正在运行的进程放入队列(PCB更新)
• 是否导致饥饿：不会
• 优点：综合了上述方法优点，综合考虑了等待时间和运行时间。对于长作业来说，随着等待时间越来越久，其响应比也会越来越大，从而避免长作业饥饿问题
• 缺点：几乎没有

3.2.2 时间片轮转

• 算法思想：公平地、轮流地为各个进程服务，让每个进程在一定时间间隔内部都可以得到响应

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

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

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

• 是否导致饥饿：不会

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

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

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

$\Delta$优先级调度

优先级进程调度算法，是把处理机分配给==就绪队列中优先级最高==的进程。
非抢占式优先级调度算法：一旦分配，中途不会被别的抢占，直到完成。
抢占式优先级调度算法：一旦分配，如果遇到优先级更高的就绪进程，就会被抢占。

1、静态优先级

静态优先级是在创建进程时确定的，在进程的整个运行期间保持不变

进程类型：一般系统进程优先级高于一般用户进程。
进程对资源的需求：对资源要求少的优先级较高。
用户要求：根据进程紧迫程度和用户付费多少确定优先级。

特点：简单易行，系统开销少，但不够精确。可能会出现优先低的进程长期得不到调度

2、动态优先级

动态优先级是指在创建进程之初，先赋予其一个优先级，然后其值随进程的推进或等待时间的增加而改变，以便获得更好的调度性能。
比如等待时间越长，优先级别增加。进程每调度一次，优先级降低一点。可以防止长作业长期垄断。

3.2.3 优先级调度算法

• 算法思想：随着计算机的发展，特别是实时操作系统的出现，越来越多的应用场景需要根据任务的紧急程度来决定处理顺序
• 算法规则：调度时选择优先级最高的作业/进程
• 用于作业/进程调度：既可以用于作业调度，也可用于进程调度，甚至还会用于I/O调度
• 是否抢占：抢占式、非抢占式都有。非抢占式只需在进程主动放弃处理机时进行调度即可，而抢占式还需在就绪队列变化时，检查是否会发生抢占
• 优点：用优先级区分紧急程度、重要程度，适用于实时操作系统。可灵活地调整对各种作业/进程的偏好程度
• 缺点：若源源不断有高优先级进程到来，可能会导致饥饿
• 是否导致饥饿：是

3.2.4 多级调度算法

• 算法思想：对其他调度算法的折中权衡
• 算法规则：
  1. 设置多级就绪队列，各级队列优先级从高到低，时间片从小到大
  2. 新进程到达时进入第1级队列，按FCFS原则排队等待被分配时间片，若用完时间片进程还未结束，则进程进入下一级队列队尾。如果此时已经在最下级队列，则重新放回该队列队尾
  3. 只有k级队列为空时，才会为k+1级队头的进程分配时间片
• 用于作业/进程调度：可用于进程调度
• 是否可抢占：抢占式算法。在k级队列的进程运行过程中，若更上级的队列(1~k-1级)中进入了一个新进程，则由于新进程处于优先级更高的队列中，因此新进程会抢占处理机，原来运行的进程放回k级队列队尾
• 优点：对各类型进程相对公平(FCFS优点)；每个新到的进程都可以很快得到响应(RR的优点)；短进程只用较少的时间就可完成(SPF的优点)；不必实现估计进程的运行时间(避免用户作假)；可灵活地调整对各类进程的偏好程度，比如CPU密集型进程、I/O密集型进程
• 缺点：会导致饥饿

3.3.5 最早截止时间优先算法(EDF)

任务的截止时间越早，优先级越高。优先级最高的排在队首。

3.3.6 最低松弛度优先(LLF)

可以理解为一个任务必须在50ms时完成，完成任务需要时间10ms，则任务最慢必须在40ms时候开始，此时40ms就叫做松弛度，即相对于当前时间还能拖拉多久。
$$松弛度=必须完成时间-当前时间-需要运行时间$$

3.3.7 优先级倒置(priority inversion problem)

高优先级进程(或线程)被低优先级进程(或线程)延迟或阻塞问题

过程：

• P3先进入，先运行，随后P2进入，优先级高于P3，发生抢占
• P1进入，优先级高于P2，发生抢占，但是其使用的临界资源被P3上锁，无法访问
• 由于无法访问，P1请求阻塞，等可以访问时再访问，此时CPU往下顺延，到了P2
• P2运行完毕，顺延到P3，P3访问完临界资源，释放资源，P1被唤醒并运行直至结束

如果要跳过P2，使P1阻塞后直接运行P3，该如何操作呢？

一种简单的解决方法是规定：假如进程P3在进入临界区后P3所占用的处理机就不允许被抢占。 此时P3执行完之后再执行其他进程。
常用方法：动态优先级。若优先级高的P1要使用已经被P3使用的临界资源时，阻塞P1，并使P3继承P1优先级(即P3优先级暂时大于P2)直到退出临界区，避免P2抢占。

$\Delta$资源

1 可重用性资源

每个单元只能分配给一个进程，不允许共享
进程使用资源顺序：①请求资源 ②使用资源 ③释放资源
每一类资源单元数相对固定，不会创建删除

2 消耗性资源

每一类资源单元数在运行期间变换，可以为0，或者很多
进程运行中可以创造资源并放入缓冲区中
进程运行中可以请求若干资源并进行消耗，不再返还系统

3 可抢占性资源

4 不可抢占性资源

通常系统中所拥有的不可抢占性资源其数量不足以满足多个进程运行的需要，使得进程在运行过程中，会因争夺资源而陷入僵局
如打印机与输入设备：进程P1占用输入设备，等待打印机
进程P2占用打印机，等待输入设备，最后谁也等不到，死锁

4、死锁

如果一个进程集合中的每个进程都在等待只能由该进程集合中的其他进程才能引发的事件，那么，该进程集合就是死锁的。(永远等不到)

4.1 必要条件（由死锁得到这些条件）

• 互斥条件：每个资源要么已经分配给了一个进程，要么就是可用资源的排它性使用（总之是当下资源不给别人用了）。每次一个资源只能被一个进程（线程）使用（哲学家问题的筷子）
• 占有和等待条件（部分已分配条件、请求和保持条件）：已经得到了某个资源的进程(可以)再请求新的资源（哲学家拿了一根筷子后可以去申请拿其他筷子）
• 不可抢占条件（非剥夺条件）：已经分配给一个进程的资源不能强制性地被抢占，它只能被占有它的进程显示地释放（筷子只能被拿着它的哲学家放下）
• 环路等待条件：死锁发生时，系统中一定有由两个或两个以上的进程组成一条环路，该环路中的每个进程都在等待着下一个进程所占有的资源（哲学家每人左手拿一根筷子，都在等其他人放下筷子）

死锁发生时四个条件必须同时满足

4.2 处理死锁

①预防死锁

预防死锁的方法是通过破坏产生死锁的四个必要条件中的一个或几个，以避免发生死锁。由于互斥条件是非共享设备所必须的，不仅不能改变，还应加以保证，因此主要是破坏产生死锁的后三个条件。

1、破坏"占有和等待"条件

为了能破坏“请求和保持”条件，系统必须保证做到：当一个进程在请求资源时，它不能持有不可抢占资源。该保证可通过如下两个不同的协议实现：

第一种协议：所有进程在开始运行之前，必须一次性地申请其在整个运行过程中所需的全部资源。
第二种协议：该协议是对第一种协议的改进，它允许一个进程只获得运行初期所需的资源后，便开始运行

2、破坏"不可抢占"条件

为了能破坏“不可抢占”条件，协议中规定，当一个已经保持了某些不可被抢占资源的进程，提出新的资源请求而不能得到满足时，它必须释放已经保持的所有资源，待以后需要时再重新申请。这意味着进程已占有的资源会被暂时地释放，或者说是被抢占了，从而破坏了“不可抢占”条件。

3、破坏"循环等待"条件

一个能保证“循环等待”条件不成立的方法是，对系统所有资源类型进行线性排序，并赋予不同的序号

②避免死锁

避免死锁同样是属于事先预防的策略，但并不是事先采取某种限制措施，破坏产生死锁的必要条件，而是在资源动态分配过程中，防止系统进入不安全状态，以避免发生死锁。这种方法所施加的限制条件较弱，可能获得较好的系统性能，目前常用此方法来避免发生死锁。

当系统处于安全状态时，可避免发生死锁；当系统处于不安全状态时，则可能进入到死锁状态。

进程得到最大需求量前，不会返回所占用资源
如P1需要最大需求10，但分配给它9后依然不会结束，需要分配给10才能结束并返还资源。

当多个进程对资源进行争夺而不能合理分配时就会发生死锁，如P1要10，P2要5，手头只有11个资源，如果P1分配9个，P2分配2个，则两者都不能满足，即都不会返还资源，进入死锁。因此资源的合理分配时避免死锁的关键

银行家算法

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

进程	已分配	还需要
P1	6	4
P2	3	2
P3	2	1

手头剩下2个资源，如何进行分配？

• 先给P3，P3结束后手头有4个资源，接下来先给P1或者P2都可以，所以有安全序列为：P3->P1->P2或者P3->P2->P1
• 先给P2，P2结束后手头有5个资源，接下来先给P1或者P3都可以，所以有安全序列：P2->P1->P3或者P2->P3->P1
• 不能先给P1，会造成死锁

所谓安全序列，就是指如果系统按照这种序列分配资源，则每个进程都能顺利完成。只要能找出一个安全序列，系统就是安全状态。安全序列可能有多个
如果分配了资源之后，系统中找不出任何一个安全序列，系统就进入了不安全状态。这就意味着之后可能所有进程都无法顺利的执行下去。当然，如果有进程提前归还了一些资源，那系统也有可能重新回到安全状态

③死锁额检测与解除

1、死锁检测算法

该方法用于检测系统状态，以确定系统中是否发生了死锁。

为了能对系统中是否已发生了死锁进行检测，在系统中必须：

1. 保存有关资源的请求和分配信息；
2. 提供一种算法，它利用这些信息来检测系统是否已进入死锁状态。

资源分配图

分配资源优先，申请资源靠后

• R1向外分配资源，P1分2个，P2分1个，此时R1已经没有资源，但是P2向其申请1个，明显申请不到，因此这种分法会进入死锁

• R1可先分配给P1两个，P1再向R2申请1个，没有问题，完成后释放空间，即恢复原状，P1周围的线可以擦掉

• 此时R1有3个资源，R2有两个资源，R1分配给P2一个，R2分配给P2一个，P2再向R1申请一个，资源数够用，因此可以顺利进行，P2周围的线也可以擦除，使各个部分成为孤立的点，说明该图是可完全简化的(可以避免死锁)

2、死锁解除算法

当认定系统中已发生了死锁，利用该算法可将系统从死锁状态中解脱出来。

• 资源剥夺法：挂起某些死锁进程，并抢占它的资源，将这些资源分配给其他的死锁进程。但应防止被挂起的进程长时间得不到资源，而处于资源匮乏的状态。
• 撤销进程法：强制撤销部分、甚至全部死锁进程并剥夺这些进程的资源。撤销的原则可以按进程优先级和撤销进程代价的高低进行
• 进程回退法：让一（或多）个进程回退足以回避死锁的地步，进程回退时自愿释放资源而不是被剥夺。要求系统保持进程的历史信息，设置还原点。

第四章 存储器管理

$\Delta$知识点补充

• 内核：内核是操作系统最基本的部分。它是为众多应用程序提供对计算机硬件的安全访问的一部分软件，这种访问是有限的，并且内核决定一个程序在什么时候对某部分硬件操作多长时间。内核的分类可分为单内核和双内核以及微内核。严格地说，内核并不是计算机系统中必要的组成部分
• CPU：中央处理器是一块超大规模的集成电路，是一台计算机的运算核心和控制核心。它的功能主要是解释计算机指令以及处理计算机软件中的数据，它与内部存储器、输入/输出（I/O）设备合称为电子计算机三大核心部件
• 寄存器：寄存器是中央处理器内的组成部份。寄存器是有限存贮容量的高速存贮部件，它们可用来暂存指令、数据和位址。
• 存储器：存储器范围最大，它几乎涵盖了所有关于存储的范畴。寄存器，内存，都是存储器里面的一种。凡是有存储能力的硬件，都可以称之为存储器
• 内存：内存是存储器的一部分，一般分为只读存储器（ROM）和随机存储器（RAM），以及最强悍的高速缓冲存储器（CACHE）。ROM应用广泛，它通常是一块在硬件上集成的可读芯片，作用是识别与控制硬件，它的特点是只可读取，不能写入。RAM的特点是可读可写，断电后一切数据都消失，我们所说的内存条就是指它了。
• 缓存：当某一硬件要读取数据时，会首先从缓存中查找需要的数据，如果找到了则直接执行，找不到的话则从内存中找。由于缓存的运行速度比内存快得多，故缓存的作用就是帮助硬件更快地运行，缓存往往使用的是RAM（断电即掉的非永久储存），所以在用完后还是会把文件送到硬盘等存储器里永久存储。电脑里最大的缓存就是内存条了
• 高速缓冲存储器Cache：当CPU处理数据时，它会先到高速缓存中去寻找，如果数据因之前的操作已经读取而被暂存其中，就不需要再从主内存中读取数据——由于CPU的运行速度一般比主内存快，因此若要经常存取主内存的话，就必须等待数个CPU周期从而造成浪费

在计算机执行时，几乎每一条指令都涉及对存储器的访问，因此要求对存储器的访问速度能跟得上处理机的运行速度。
存储器的速度必须非常快，能与处理机的速度相匹配，否则会明显地影响到处理机的运行。
此外还要求存储器具有非常大的容量，而且存储器的价格还应很便宜。

1、存储器的多层结构

存储层次至少应具有三级：最高层为CPU寄存器，中间为主存，最底层是辅存。在较高档的计算机中，还可以根据具体的功能细分为寄存器、高速缓存、主存储器、磁盘缓存、固定磁盘、可移动存储介质等6层

磁盘缓存

• 由于目前磁盘的I/O速度远低于对主存的访问速度，为了缓和两者之间在速度上的不匹配，而设置了磁盘缓存，主要用于暂时存放频繁使用的一部分磁盘数据和信息，以减少访问磁盘的次数。

• 磁盘缓存与高速缓存不同，它本身并不是一种实际存在的存储器，而是利用主存中的部分存储空间暂时存放从磁盘中读出(或写入)的信息。

• 数据都需要放入主存才能调用CPU使用，其中主存和CPU的速度匹配问题交给Cache

  当进程需要存储空间时，就分配给它；然后当它运行结束后，再把存储空间回收回来。
  如果内存太小，容不下所有的进程，那么就需要把内存中暂时不能运行的进程转到磁盘上，然后再把磁盘上的另一个进程装入内存

2、程序的装入和链接

用户程序要在系统中运行，必须先将它装入内存，然后再将其转变为一个可以执行的程序，通常都要经过以下几个步骤：
①编译：由编译程序(Compiler)对用户源程序进行编译，形成若干个目标模块(Object Module)；(高级语言–>机械语言)
②链接：由链接程序(Linker)将编译后形成的一组目标模块以及它们所需要的库函数链接在一起，形成一个完整的装入模块(Load Module)；
③装入：由装入程序(Loader)将装入模块装入内存

其中物理地址(段地址*16+偏移地址)是绝对地址；逻辑地址(段地址：偏移地址)是相对地址

一个酒店有三层，每层10个房间，从一楼第一个开始依次编号1,2…
对于同一个房间(如第12间)，有两种叫法
可以说这是编号12的房间，也可以说这是第二层的第2个房间
这就是物理地址与逻辑地址的区别

2.1 程序的装入

有一个指令P：往地址为80的存储单元中写入1

①绝对装入方式

在编译时，如果知道程序将放到内存中的哪个位置，编译程序将产生绝对地址的目标代码。装入程序按照装入模块中的地址，将程序和数据装入内存。
如：装入模块要从地址为 100 的地方开始存放，则指令P经编译后变成"往地址为180的存储单元写入1"

绝对装入只适用于单道程序环境。（内存当中同一时刻只会有一个程序正在运行)程序中使用的绝对地址，可在编译或汇编时给出，也可由程序员直接赋予。通常情况下都是编译或汇编时再转换为绝对地址

②静态重定位

编译、链接后的装入模块的地址都是从0开始的，指令中使用的地址、数据存放的地址都是相对于起始地址而言的逻辑地址。 将装入模块装入到内存的适当位置。装入时对地址进行“重定位”，将逻辑地址转换为物理地址（地址变换是在装入时一次完成的）
如：装入模块要从地址为 100 的地方开始存放，指令P依旧是往地址80放数据，不过装入时会将其作为一个偏移量，即识别为100+80，最终也是地址180

静态重定位的特点是在一个作业装入内存时，必须分配其要求的全部内存空间，如果没有足够的内存，就不能装入该作业。作业一旦进入内存后，在运行期间就不能再移动，也不能再申请内存空间。

③动态重定位

装入程序把装入模块装入内存后，并不会立即把逻辑地址转换为物理地址，而是把地址转换推迟到程序真正要执行时才进行。
因此装入内存后所有的地址依然是逻辑地址。这种方式需要一个重定位寄存器的支持。
如：装入模块要从地址为 100 的地方开始存放，假设此时已经装入完毕，与静态重定位不同的是，此时指令P里依旧是逻辑地址80，直到内存扫描到指令P要运行程序时，逻辑地址再根据程序起始地址进行重定位(起始地址+偏移量)

1. 动态重定位可将程序分配到不连续的存储区中；
2. 在程序运行前只需装入它的部分代码(当前需要的指令代码)即可投入运行，然后在程序运行期间，根据需要动态申请分配内存；
3. 便于程序段的共享，可以向用户提供比存储空间大得多的地址空间

2.2 程序的链接

①静态链接

在程序运行之前，先将各目标模块及它们所需的库函数链接成一个完整的装配模块，以后不再拆开。链接的任务是：
①对相对地址进行修改（独立的逻辑地址变成完整的逻辑地址，如A程序段是0–>99，B程序段是0–>49，则装起来就是0–>149）
②变换外部调用符号

②装入时动态链接

指将用户源程序编译后所得到的一组目标模块，在装入内存时，采用边装入边链接的链接方式，即在装入一个目标模块时，若发生一个外部模块调用事件，将引起装入程序去找出相应的外部目标模块，并将它装入内存

优点：①便于修改和更新 ②便于实现对目标模块的共享

③运行时动态链接

在许多情况下，应用程序在运行时，每次要运行的模块可能是不相同的。但由于事先无法知道本次要运行哪些模块，故只能是将所有可能要运行到的模块全部都装入内存，并在装入时全部链接在一起。显然这是低效的，因为往往会有部分目标模块根本就不运行，因此运行时动态链接时发现模块没有用到就不链接，提高了效率

3、存储管理分配方式

内部碎片：已经被分配出去却不能被利用的内存空间

如一个进程块大小100，其中只有50是有程序段的，剩下50没有被使用到，即内部碎片

外部碎片：由于空间太小了无法分配给申请内存空间的新进程的内存空闲区域，当下不属于任何进程

如一个内存大小100，有3个进程大小均为30，将三个进程都装入内存后，还剩下10的空间，这部分空间不属于任何进程，即外部碎片

连续分配管理方式

①单一连续分配

在单道程序环境下，当时的存储器管理方式是把内存分为系统区和用户区两部分，系统区仅提供给OS使用，它通常是放在内存的低址部分。而在用户区内存中，仅装有一道用户程序，即整个内存的用户空间由该程序独占。这样的存储器分配方式被称为单一连续分配方式

优点：实现简单；无外部碎片；可以采用覆盖技术扩充
缺点：只能用于单用户、单任务的操作系统中；有内部碎片；存储器利用率极低。

②固定分区分配

将整个用户空间划分为若干个固定大小的分区，在每个分区中只装入一道作业

当某用户程序要装入内存时，由操作系统内核程序根据用户程序大小检索该表，从中找到一个能满足大小的、未分配的分区，将之分配给该程序，然后修改状态为“已分配”

分区号	大小	起始地址	状态
1	2	8	已分配
2	2	10	未分配

1.分区大小相等

缺乏灵活性，但是很适合用于用一台计算机控制多个相同对象的场合（比如：钢铁厂有n个相同的炼钢炉，就可把内存分为n个大小相等的区域存放n个炼钢炉控制程序）

2.分区大小不等

增加了灵活性，可以满足不同大小的进程需求。根据常在系统中运行的作业大小情况进行划分（比如：划分多个小分区、适量中等分区、少量大分区）

③动态分区分配

这种分配方式不会预先划分内存分区，而是在进程装入内存时，根据进程的大小动态地建立分区，并使分区的大小正好适合进程的需要。因此系统分区的大小和数目是可变的。

动态分区分配没有内部碎片，但是有外部碎片
如果内存中空闲空间的总和本来可以满足某进程的要求，但由于进程需要的是一整块连续的内存空间，因此这些"碎片"不能满足进程的需求。
可以通过紧凑技术来解决外部碎片。

系统需要使用怎样的数据结构记录内存使用情况？


当很多个空闲分区都能满足需求时，应该选择哪个分区进行分配？

把一个新作业装入内存时，须按照一定的动态分区分配算法，从空闲分区表（或空闲分区链）中选出一个分区分配给该作业

分配算法

1.首次适应算法

• 算法思想：每次都从低地址(头部)开始查找，找到第一个能满足大小的空闲分区
• 如何实现：空闲分区以地址递增的次序排列。每次分配内存时顺序查找空闲分区链(或空闲分区表)，找到大小能满足要求的第一个空闲分区
• 优点：综合看性能最好。算法开销小，回收分区后一般不需要对空闲分区队列重新排序

2.最佳适应算法

• 算法思想：为了保证当"大进程"到来时能有连续的大片空间，可以尽可能多地留下大片的空闲区，即优先使用更小的空闲区
• 如何实现：空闲分区按容量递增次序链接。每次分配内存时顺序查找空闲分区链（或空闲分区表），找到大小能满足要求的第一个空闲分区
• 优点：会有更多的大分区被保留下来，更能满足大进程需求
• 缺点：每次都选最小的分区进行分配，会留下越来越多的、很小的、难以利用的内存块。因此这种方法会产生很多的外部碎片

3.最坏适应算法

• 算法思想：在每次分配时优先使用最大的连续空闲区，这样分配后剩余的空闲区就不会太小，更方便使用
• 如何实现：空闲分区按容量递减次序链接。每次分配内存时顺序查找空闲分区链（或空闲分区表），找到大小能满足要求的第一个空闲分区
• 优点：可减少难以利用的小碎片
• 缺点：每次都选最大的分区进行分配，虽然可以让分配后留下的空闲区更大，更可用，但是这种方式会导致较大的连续空闲区被迅速用完，如果之后有"大进程"到达，就没有内存分区可用了

4.邻近适应算法

• 算法思想：每次都从上次查找结束的位置开始检索
• 如何实现：空闲分区以地址递增的顺序排列(可排成一个循环链表)。每次分配内存时从上次查找结束的位置开始查找空闲分区链（或空闲分区表），找到大小能满足要求的第一个空闲分区
• 优点：不用每次都从低地址的小分区开始检索，算法开销小(使用完后不用重新排序)
• 缺点：虽然中和了一些最坏适应算法，但仍会使高地址的大分区被用完

如何进行分区的分配与回收操作？
初始情况↓ :
​

在内存装入一个进程5(4MB)，内存情况与分区变为

在进程3下装入一个进程5(4MB)，内存情况与分区变为↓

非连续分配管理方式

出现的原因

固定分区分配：缺乏灵活性，会产生大量的内部碎片，内存的利用率很低
动态分区分配：会产生很多外部碎片，虽然可以用“紧凑”技术来处理，但是“紧凑”的时间代价很高

如果允许将一个进程分散地装入到许多不相邻的分区中，便可充分地利用内存，而无需再进行“紧凑”

基本分页存储管理

把内存分为一个个相等的小分区，再按照分区大小把进程拆分成一个个小部分

• 将内存空间分为一个个大小相等的分区，每个分区就是一个"页框"，或称"内存块", “物理块”。每个页框有一个编号，即"页框号"(或者“内存块号", “物理块号”)，页框号从0开始

• 将用户进程的地址空间也分为与页框大小相等的一个个区域。称为"页"或"页面"。每个页面也有一个编号，即"页号", 页号也是从0开始

• 用户进程页放入内存空间页框

• 如一个用户进程大小为23MB，内存空间有40M，分为4个页框，每个页框是10MB

  用户进程无法直接放入内存的分区中(大小不够)，因此用户进程需要分为3个页，页大小和页框相同都是10MB，第三个页会有7MB的内部碎片。将这三个页放入内存空间中**(可以不按顺序，用编号指定)**，从而实现装入内存

  如何知道程序段处于哪个"页"(页号是多少)？

  页号=$\frac{逻辑地址}{页面大小}$，如进程一个页大小为10，则位置65的程序段页号为65/10=6
所以其页号为6；位置为5的程序段页号为5/10=0，即0号页

  页内偏移量是什么？如何计算？

  顾名思义，页内偏移量就是相对于当前页的偏移量，在计算页号时得到的余数就是当前页的偏移量。页表项是表中的每一行，即第X块
  如一个进程页大小为10，位置65的程序段页号算出为65/10=6▪▪▪▪▪▪5，即页号为6，偏移量为5，也就是说它在页号6往下数5的位置。

  为了实现Map映射，OS为每个进程创立了一张页表(放内存)，用来实现对应关系

  页号(进程)	块号(内存)
  0	3
  1	6
  2	4
  …	…

  页号实际上在页表中是不存在的，这里这样画是为了方便理解

  进程的页与进程的页框如何实现映射？

  通过逻辑地址和页长计算得出当前程序段所处的页号和偏移地址，接着根据页表映射关系，将页号对应块号，偏移量变成块号的偏移量。

  如：进程页长为10，程序段逻辑地址为15，页表情况如上图，求程序段在内存中的物理地址。
  15/10=1▪▪▪▪▪▪5，因此有页号为1，偏移地址为5
  根据上表可知，页号1对应块号6，因此程序段在内存中块号6，偏移地址为5的位置
  又因为块大小等于页大小，即物理地址为65

  假设某系统物理内存大小为4GB，页面大小为4KB，则每个页表项至少应该为多少字节？

  页号总量=$\frac{4GB}{4KB}=2^{20}$，即页表项(第X块)至少能够表示到这么多号，即20个二进制位，至少需要3个字节

  通常会在系统中设置一个页表寄存器（PTR），存放页表在内存中的起始地址F和页表长度M，进程未执行时，页表的始址和页表长度放在进程控制块（PCB）中，当进程被调度时，操作系统内核会把它们放到页表寄存器中

基本分段存储管理

进程的地址空间：按照程序自身的逻辑关系划分为若干个段，每个段都有一个段名，每段从0开始编址
内存分配规则：以段位单位进行分配，每个段在内存中占据连续空间，但各段之间可以不相邻

同理，分段存储也会有相应段表

• 根据逻辑地址得到段号、段内地址
• 段表段号从0开始，逻辑地址段号(从0开始)不能大于或等于段表长度，否则越界中断
• 查询段表，找到对应的段表项，对应的基址就是起始地址
• 检查段内地址是否超过段长，超过则越界中断，否则继续执行
• 基址+段内地址得到物理地址

分页、分段管理的对比

• 页是信息的物理单位。分页的主要目的是为了实现离散分配，提高内存利用率。分页仅仅是系统管理上的需要，完全是系统行为，对用户是不可见的。

• 段是信息的逻辑单位。分段的主要目的是更好地满足用户需求。一个段通常包含着一组属于一个逻辑模块的信息。分段对用户是可见的，用户编程时需要显式地给出段名。

• 页的大小固定且由系统决定。段的长度却不固定，决定于用户编写的程序。

• 分页的用户进程地址空间是一维的，程序员只需给出一个记忆符(即页的具体地址)即可表示一个地址

  • 页在进程上连续，第0页的最后一个地址和第1页的第一个地址在数值上是连续的，如页号两位，页面偏移量两位的地址，第0页最后一个地址是0011，第1页第一个地址是0100，正好连续，因此说这是一维的，页号和偏移量都存在一个地方，绝对路径(一个地址指明是哪一页哪个位置，如下图)。

• 分段的用户进程地址空间是二维的，程序员在标识一个地址时，既要给出段名，也要给出段内地址

  • 程序被编译成多个段时，比如数据段、代码段、附加段等，每个段的段号是编译器自动分配的，每个段的长度不定。因此虽然他们的段号连续，但是其总地址不连续，如段号两位，段内偏移量两位，第0段的最后一个地址不一定是0011，由于长度不一，因此可能是0001；而第1段的开始却是0100，明显这两者不连续，因此确认一个地址需要段号和段内偏移量才能确定，相对路径，所以说是二维的。
    

• 分段比分页更容易实现信息的共享和保护

  • 因为分页是以页作为单位，但如果页中有部分内容不想共享，则很难实现；而分段由于可以大小不一，因此只需要规定当前段的大小即可实现按需要共享

• 不能修改的代码称为纯代码或可重入代码(不属于临界资源)，可共享；可修改的代码不可共享(比如一个代码段中有很多变量，各进程并发访问可能造成数据不一致)

段页式存储管理

分页管理

优点：内存空间利用率高，不会产生外部碎片，只会有少量的页内碎片
缺点：不方便按照逻辑模块实现信息的共享和保护

分段管理

优点：很方便按照逻辑模块实现信息的共享和保护
缺点：如果段长过大(16位无法表示)，为其分配很大的连续空间会很不方便。另外段式管理会产生外部碎片(可用紧凑，不过代价很大)

段页式管理(先分段再分页，二维)

段号的位数决定了每个进程最多可以分几个段
页号位数决定了每个段最多分多少页
页内偏移量决定了页面大小、内存块大小是多少

每个段对应一个段表项，每个段表项由段号、页表长度、页表存放块号(页表真实地址组成)。每个段表项长度相等，段号是隐含的

• 首先逻辑地址根据段表查询到自己段号所对应的页表，接着根据查询到的页表存放块号去访问内存中页表
• 页表中的页号是相对页号(虚拟)，其对应的块号是内存真实块号，如上0号段被分为了两页，4KB的内容在0号页(相对当前页表)，3KB的内容在1号页(相对当前页表)，进程根据页表将这两页装入内存
• 注意，这里一页大小4KB，所以1号页并没有装满其对应的块号，内存中产生内部碎片
• 每段中被分出来的部分都有自己的段号、页号、页内偏移量
  

基本地址变换机构

时间局部性：如果执行了程序中的某条指令，那么不久后这条指令很有可能再次执行；如果某个数据被访问过，不久之后该数据很可能再次被访问(因为程序中存在大量循环)

空间局部性：一旦程序访问了某个存储单元，在不久之后，其附近的存储单元也有可能被访问(因为很多数据在内存中都是连续存放的)

具有快表的地址变换机构

什么是快表？

快表，又称联想寄存器(TLB)，是一种访问速度比内存快很多的高速缓冲存储器(页表的cache)，用来存放当前访问的若干页表项，以加速地址变换的过程。与此对应，内存中的页表常称为慢表。

使用过程

当有进程需要查询页表时，首先查看快表，起初快表为空，快表查询不到相应块号就会去访问内存的表，随后快表将这一数据读入；下次若再有访问此块号的需求就可以直接在快表中查询到并访问

若快表命中，则访问某个逻辑地址仅需一次访存(根据页表找块号)即可

若快表未命中，则访问某个逻辑地址需要两次访存（一次查表，一次找块。若快表已满，则必须按照一定的算法对旧的页表项进行替换）因为局部性原理，一般来说快表的命中率可以达到90%以上

二级页表

为什么要二级页表？

1.页表必须连续存放，因此当页表很大时，需要占用很多个连续的页框
2.没有必要让整个页表常驻内存，因为进程在一段时间内可能只需要访问某几个特定的页面。

页表项的大小如何计算？页表大小如何计算？

页表项大小取决于需要表示的页号+需要表示的页内偏移量(取决于页面大小)
如一个页面大小是4KB，那么它需要表示的页内偏移量为$2^{12}B$，即需要12位，若系统为32位，则剩下的20位可以用来表示页号，最多可以表示$2^{20}$页。而这32位都存放在页表项中，即一个页表项4B。
而页表由很多页表项组成，具体多少页表项由页号决定，如有$2^{20}$个页表项，则页表大小为$2^{20}B\times 4B=2^{22}B=4MB$，即页表大小4MB

页表如何分割成更小的页表？

页表被分割的前提是当前页表很大，用来搜索很不方便，如有一本很厚目录，目录中没有大标题，而是直接指向最底层的内容，因此需要进行分割(加大标题)

如上，一级页表有4MB，页面大小是4KB，页表项是4B，我们将一级页表看作一个新程序，这个程序中可以分为$\frac{4MB}{4KB}=2^{10}页$，每一个页就是一个二级页表，一个页能装$\frac{4KB}{4B}=2^{10}项$，页内偏移量是$4KB=2^{12}B$，即12位。

即原来一个4MB的页表被分为了$2^{10}$个大小为$4KB(2^{12}B)$的二级页表，二级页表中每个页表项为4B，所以二级页表有$2^{10}$项

页表项中的32位起初前20位用来指引页号，后12位用来指引页内偏移量；现在前10位变为指引二级页表($2^{10}个页表中的哪一个$)，后10位指引具体哪个页号，再后12位指引页面偏移量。

假设此时被调用的是0号二级页表第5项，则进程的某一程序段寻找对应的内存块时，首先会问一级页表：
“请问我该去哪个内存块？”
一级页表说：“让我看看你地址前10位…找到了，你去Z号内存块里0号二级页表看看。”
然后程序段再问二级页表：“一级页表让我来找你，请问我该去哪个内存块？”
0号二级页表说：“让我看看你地址中间10位，你是我的第5项，你去内存块X看看吧”
然后程序段来到对应内存块X，问内存：“请问我具体在内存块哪个位置呢？”
X号内存块说：“我看看你最后12位…你的偏移量是Y，去Y位置吧！”
接着程序段装入内存块，结束。

如何实现在需要时才将页面导入内存呢？

可以在需要访问页面时才把页面调入内存(虚拟存储技术)，可以在页表项中增加一个标志位，用于表示该页面是否已经调入内存。
若想访问的页面不在内存中，则产生缺页中断(内中断)，然后将目标页面从外存调入内存。

内存分配

为了便于内存分配，通常将分区按其大小进行排队，并为之建立一张分区使用表，其中各表项包括每个分区的起始地址、大小及状态(是否已分配)，每个分区可放一个进程

4、内存空间的扩充

①覆盖技术

• 出现的原因：解决“程序大小超过物理内存总和”的问题
• 思想：将程序分为多个段(多个模块)。常用的段常驻内存，不常用的段在需要时调入内存。内存中分为一个“固定区”和若干个“覆盖区”。需要常驻内存的段放在"固定区"中，调入后就不再调出(除非运行结束)；不常用的段放在"覆盖区"，需要用到时调入内存，用不到时调出内存

可以让不可能同时被访问的程序段共享同一个覆盖区，如游戏的关卡1与关卡10

②交换技术

• 思想：内存空间紧张时，系统将内存中某些进程暂时换出外存(挂起)，把外存中某些已具备运行条件的进程换入内存(进程在内存与磁盘间动态调度)

应该外存的什么位置保存被换出的进程？

具有对换功能的操作系统中，通常把磁盘空间分为文件区和对换区两部分。文件区主要用于存放文件，主要追求存储空间的利用率，因此对文件区空间的管理采用离散分配方式；对换区空间只占磁盘空间的小部分，被换出的进程数据就存放在对换区。由于对换的速度直接影响到系统的整体速度，因此对换区空间的管理主要追求换入换出速度，因此通常对换区采用连续分配方式，对换区的I/O速度比文件区的更快

什么时候应该交换？

交换通常在许多进程运行且内存吃紧时进行，当系统负荷降低时就暂停。例如：在发现许多进程运行时经常发生缺页，就说明内存紧张，此时可以换出一些进程；如果缺页率明显下降，就可以暂停换出

应该换出哪些进程？

优先换出阻塞进程；可换出优先级低的进程；为了防止优先级低的进程在被调入内存后很快又被换出，有的系统还会考虑进程在内存的驻留时间

覆盖和交换的区别？

覆盖是在同一个程序或进程中的；交换是在不同进程或作业之间的

第五章 虚拟存储器

传统存储管理方式的缺点

一次性：作业必须一次性全部装入内存后才能开始运行。这会造成两个问题：①作业很大时，不能全部装入内存，导致大作业无法运行；②当大量作业要求运行时，由于内存无法容纳所有作业，因此只有少量作业能运行，导致多道程序并发度下降(内存中只能装几个进程)
驻留性：一旦作业被装入内存，就会一直驻留在内存中，直至作业运行结束。事实上，在一个时间段内，只需要访问作业的一小部分数据即可正常运行(虚拟技术依据)，这就导致了内存中会驻留大量的、暂时用不到的数据，浪费了宝贵的内存资源。

1. 什么是虚拟内存？

1. 基于局部性原理(当前被访问过的数据很可能再次被访问)，在程序装入时，可以将程序中很快会用到的部分装入内存，暂时用不到的部分留在外存，此时可让程序执行
2. 在程序执行过程中，当所访问的信息不在内存时，由操作系统负责将所需信息从外存调入内存，然后继续执行程序
3. 若内存空间不够，由操作系统将内存中暂时用不到的信息换到外存
4. 在操作系统的管理学，在用户看来似乎又一个比实际内存大得多的内存，这就是虚拟内存

• 虚拟内存的最大容量是由计算机的地址结构(CPU寻址范围)确定的
• 虚拟内存的实际容量=min(内存和外存容量之和，CPU寻址范围)

如：某计算机地址结构为32位，按字节编址，内存大小为512MB，外存大小为2GB
则虚拟内存最大容量为$2^{32}B$=4GB
虚拟内存实际容量=$min(2^{32}B,512MB+2GB)$

特征

• 多次性(基础)：无需在作业运行时一次性全部装入内存，而是允许被分成多次调入内存
• 对换性：在作业运行时无需一直常驻内存，而是允许在作业运行过程中，将作业换入、换出
• 虚拟性：从逻辑上扩充了内存的容量，使用户看到的内存容量，远大于实际的容量

2. 如何实现虚拟内存技术

• 请求分页存储管理
• 请求分段存储管理
• 请求段页式存储管理

传统存储管理方式不管分页还是分段，都会将整个进程放入内存中，即使每次只有少部分内容被访问
其与传统存储管理方式的区别在于：当所访问的信息不在内存时，由操作系统负责将所需信息从外存调入内存，然后继续执行程序；若内存空间不够，由操作系统负责将内存中暂时用不到的信息换出到外存

请求分页存储管理

为了实现请求分页，系统必须提供一定的硬件支持。计算机系统除了要求一定容量的内存和外存外，还需要有请求页表机制(要访问页的状态信息表)、缺页中断机构(当在内存中找不到内容时触发)以及地址变换机构(页面在外存与内存的地址映射)
当内存空间不够时，要实现"页面置换"，操作系统需要通过某些指标来决定到底换出哪个页面；有的页面没有被修改过，就不用再浪费时间写回外存；有的页面修改过，就需要将外存中的旧数据覆盖，因此，操作系统也需要记录各个页面是否被修改的信息

• 如上，当需要访问某一个页时，首先会查看页表，观察其是否在内存中(状态位)，若在直接去对应内存块号处进行访问；若不在则产生缺页中断(阻塞)，需要从外存将需要的页面调入(就绪)
• 页面在外存的地址可以通过页表得知，若此时内存有空闲区，则将该页面分配到空闲内存块号并更新页表即可；若当前内存已满，则需要根据算法置换出暂时用不到的页面
• 被置换出的页面若修改位为1，则写回外存时需要对修改过的部分进行更新；若修改位为0，说明此页面没有被修改过，因此也就没有重新写回外存的必要(外存中有原数据)，提高效率。
• 同样可以引入快表使查询过程更有效率，一般来说只需修改快表中的数据，只有要将快表项删除时才需要写回内存中的慢表，减少访存次数
• 换入/换出页面都需要启动慢速的I/O操作，可见，如果换入/换出太频繁，会有很大开销
• 影响页面换进换出效率的若干因素
  • 页面置换算法
  • 写回磁盘的频率
  • 读入内存的频率

页面置换算法

在进程运行过程中，若其所要访问的页面不在内存，而需把它们调入内存，但内存已无空闲空间时，为了保证该进程能正常运行，系统必须从内存中调出一页程序或数据送到磁盘的对换区中。但应将哪个页面调出，须根据一定的算法来确定。通常，把选择换出页面的算法称为页面置换算法(Page-Replacement Algorithms)。置换算法的好坏将直接影响到系统的性能

1. 最佳适应算法(OPT)

提前知道访问顺序，淘汰页面时选择后边不再使用的页面或者很长时间不用被访问的页面淘汰，这样可以保证最低的缺页率

1. 首先知道需要访问的页面序列是7,0,1,2,0,3……

2. 内存初始大小为3个内存块，起初里面没有内容，因此最初要访问的3个页面都产生缺页中断，通过查询页表后从外存调入内存，此时内存被占满

3. 当"访问页面2"的请求来临时，操作系统就会对比当前内存中的三个页面7,0,1在后期访问序列中哪一个不再被访问或者最长时间不被访问，就将其置换出去

4. 易知，7最长时间不被访问，因此被置换，其余步骤同理……

5. 整个过程共进行20次操作，缺页中断发生9次，9次缺页中断中包括6次页面置换。
   $$\begin{gathered} 缺页率=\frac{缺页次数}{总操作数} \\ \therefore 缺页率=\frac{9}{20}=45\% \end{gathered}$$

   但是在实际使用过程中，我们无法知道页面的访问序列(因为用户的请求时随机的)，因此最佳置换算法实际上无法实现

2. 先进先出置换算法(FIFO)

每次选择淘汰的页面是最早进入内容的页面
可通过把调入内存的页面根据调入的先后顺序放入队列实现

1. 内存初始大小为3个内存块，起初里面没有内容，因此最初要访问的3个页面都产生缺页中断，通过查询页表后从外存调入内存，此时内存被占满
2. 访问页面0的请求来临时，操作系统通过查询队列得知，页面3是最先调入内存的，因此将其置换，后边同理……
3. 通过观察可以发现，有些页面刚刚被调出内存不久又被调进来，缺页中观次数多，因此缺页率高，频繁在内外存中调动也会影响效率

3. 最近最久未使用置换算法(LUR)

每次淘汰的页面是最近最久未使用的页面
每条页表项中用访问字段记录该页面自上次被访问所经历的时间T。当需要淘汰一个页面时，选择现有页面T值最大的，即最近最久没有使用的页面

1. 内存初始大小为4个内存块，起初里面没有内容，请求通过查询页表后从外存调入内存，产生4次缺页中断后，此时内存被占满
2. 后边7,2,1,8页面请求都可以在内存中找到，因此不发生置换，也没有缺页中断。
3. 到页面3请求时，内存中找不到，发送缺页中断，需要置换页面。操作系统查询页表得到当前在内存块中的各个页面的访问字段，得到最长时间没被访问的是页面7，因此3置换7，后边同理……
4. 该算法的实现需要专门的硬件支持，虽然算法性能好，但是实现困难，开销大

4. 时钟置换算法(CLOCK)

为每个页面设置一个访问位，再将内存中的页面通过链接指针链接成一个循环队列。当某页被访问时，其访问位为1。当需要淘汰一个页面时，只需检查页的访问位：如果是0，就选择将该页换出；如果是1，则将它置为0，暂不换出，继续检查下一个页面，若第一轮扫描中所有页面都是1，则将这些页面的访问位依次置为0后，再进行二轮扫描(第二轮扫描中一定会有访问位为0的页面，因此简单的CLOCK算法选择一个淘汰页面最多会经过两轮扫描)

1. 内存共有3块，起初内存块都为空，指针指向第一个位
2. 页面2发送请求，内存中找不到，发生缺页中断后将页面2调入内存，并将其访问位置1，指针下移。页面3的添加同理
3. 接着又有来自页面2的请求，在内存中可以找到，因此指针不动；接着页面1请求发生缺页中断，将其装入并将访问位置1后，指针回到开头。
4. 到页面5请求时，内存已满，需要置换页面。此时指针在开头，查看页面2的访问位，发现是1，因此将其置0并下移；发现3页面的访问位也是1，置0并下移，1页面同理，指针又回到页面2处
5. 再次查看页面2的访问位，发现是0，因此页面5置换它，并将访问位置1，指针下移……后边的2,4,5,3页面请求同理
6. 接着页面2发送请求，此时内存中正好有页面2，因此不发生缺页中断，将其对应页表项中的访问位由0置1，指针不动
7. 再接着是页面5请求，内存中没有找到，需要页面置换。指针此时在页面2处，查看访问位，发现是1，因此将其置0，指针下移到页面4处，发现其访问位为0，因此将其置换，并将页面5的访问位置为1，指针移动
8. 最后页面2同理

改进型时钟置换算法

简单的时钟置换算法仅考虑到一个页面最近是否被访问过。事实上，如果被淘汰的页面没有被修改过就不用执行I/O操作写回外存。只有被淘汰的页面被修改过时，才需要写回外存
因此，除了考虑一个页面最近有没有被访问过外，操作系统还应该考虑页面有没有被修改过。在其他条件都相同时，应优先淘汰没有修改过的页面，避免I/O操作。
修改位=0，表示没有修改过；为1代表修改过
用**（访问位，修改位）的形式表示各页面状态。如（1,1）表示一个页面近期被访问过且被修改过**
将所有可能被置换的页面排成一个循环队列

• 第一轮：从当前位置开始扫描到第一个（0,0）的帧用于替换。本轮扫描不修改任何标志位
• 第二轮：若第一轮扫描失败，则重新扫描，查找第一个（0,1）的帧用于替换。本轮将所有扫描过的帧访问位设为0
• 第三轮：若第二轮扫描失败，则重新扫描，查找第一个（0,0）的帧用于替换。本轮扫描不修改任何标志位
• 第四轮：若第三轮扫描失败，则重新扫描，查找第一个（0,1）的帧用于替换

由于第二轮已将所有帧的访问位设为0，因此经过第三轮，第四轮的扫描一定会有一个帧被选中，改进型CLOCK算法选择淘汰哪个界面最多会进行四轮扫描

页面缓冲算法(PBA)

PBA算法的主要特点是：①显著降低了页面换进、换出频率，使磁盘I/O操作次数大为减少，因而减少了页面换进、换出开销；②正是由于换入换出的开销大幅度减小，才能使其采用一种较为简单的置换策略，如先进先出算法，它不需要特殊硬件支持，实现起来非常简单

访问内存的有效时间

1. 被访问页在内存中，且其对应的页表项在快表中，此时不存在缺页中断

   $T=q+t$ //T为内存的有效时间，q为查快表时间，t为访问物理地址时间

2. 被访问页在内存中，且其对应的表项不在快表中

   $T=q+t+q+t$ //查找快表的时间q、查找页表的时间t(访存)、修改快表的时间、访问实际物理地址的时间t(访存)

3. 该访问页不在内存中

   $T=q+t+G+q+t$ //查找快表时间q、查找页表时间t、处理缺页中断时间G、更新快表时间q和访问实际物理地址时间t。

抖动现象

刚刚换出的页面马上又要换入内存，刚刚换入的页面马上又要换出外存，这种频繁的页面调度行为称为抖动，或颠簸。产生抖动的主要原因是进程频繁访问的页面数目高于可用的物理块数(分配给进程的物理块不够)

• 驻留集：指请求分页存储管理中给进程分配的内存块的集合
• 工作集：指在某段时间间隔里，进程实际访问页面的集合

请求分段存储管理

为了实现请求分段式存储管理，应在系统中配置多种硬件机构，以支持快速地完成请求分段功能。与请求分页系统相似，在请求分段系统中所需的硬件支持有段表机制、缺段中断机构，以及地址变换机构。

在分段系统中，由于每个分段在逻辑上是相对独立的，因而比较容易实现信息保护。目前，常采用以下几种措施来确保信息的安全。

①越界检查；②存取控制检查；③环保护机构

第六章 输入输出系统

1、I/O设备

什么是I/O设备？

I/O设备就是可以将数据输入到计算机，或者可以接收计算机输出数据的外部设备

分类

按使用特性分类

1. 人机交互类外部设备(数据传输速度慢)：鼠标、键盘
2. 存储设备(数据传输速度快)：移动硬盘、光盘
3. 网络通信设备(速度介于快慢之间)：调制解调器等

按传输速率分类

1. 低速设备(每秒几个到几百字节)：鼠标、键盘
2. 中速设备(每秒上万字节)：激光打印机
3. 高速设备(每秒千兆字节)：磁盘

按信息交换单位分类

1. 块设备(速率高，可寻址，可随意读写任一块)：磁盘
2. 字符设备(速率慢，不可寻址，使用中断驱动)：键盘

电子部件

I/O设备由机械部件(用户使用)和电子部件组成

CPU无法直接控制I/O设备的机械部件，因此需要电子部件作为CPU和I/O设备机械部件之间的"中介"，用于实现CPU对设备的控制。
通常是一块插入主板扩充槽的印刷电路板(I/O控制器)

• 地址线：说明具体控制哪个设备
• 控制线：发出具体I/O指令
• 数据寄存器：用于存放CPU传送出来的数据以及准备放入CPU的数据
• 控制器寄存器：用于存放CPU执行I/O指令的参数，I/O逻辑可读出
• 状态寄存器：存放当前I/O设备的状态(是否准备好)，CPU读出并分析操作时机
• 一个I/O控制器可能会对应多个设备

假设此时输出一个数据

1. 首先CPU通过地址线和控制线告诉I/O逻辑自己要对哪个设备执行什么操作
2. I/O逻辑将当前设备的状态放入状态寄存器
3. CPU读状态寄存器，发现此时状态适合输出
4. CPU通过数据总线将数据写入数据寄存器中
5. 将I/O指令需要的参数放到控制寄存器中
6. I/O逻辑取出寄存器中内容并识别，将其通过I/O设备接口输出到设备

寄存器地址

数据寄存器、控制寄存器、状态寄存器可能有多个(如：每个控制/状态寄存器对应一个具体的设备)，且这些寄存器都要有相应的地址，才能方便CPU操作。有的计算机会让这些寄存器占用内存地址的一部分，称为内存映像I/O；另一些计算机则采用I/O专用地址，即寄存器独立编址

2、I/O控制方式

CPU控制I/O设备放入内存的方式

1. 程序直接控制方式

最原始的I/O设备与CPU控制方法，有轮询操作因此CPU利用效率低，具体过程请看【第六章/I/O设备/电子部件】

2. 中断驱动方法

由于I/O设备很慢，因此在CPU发出指令后，可将等待I/O指令的进程阻塞，先执行其他进程。当I/O设备完成返回后，控制器会发送中断信息给CPU，CPU收到后再回过头来处理，从而节约了等待时间

• CPU会在每个指令周期的末尾检查中断
• 中断处理过程需要保存、恢复进程的运行环境，这个过程需要一定开销。因此中断频率太高也会影响效率

​

1.CPU干预频率：
每次I/O开始前、完成后需要CPU介入；等待I/O完成过程中CPU可以切换到别的进程

2.数据传送单位：
每次读/写一个字

3.数据流向：
读：I/O设备->CPU->内存
写：内存->CPU->I/O设备

优点：CPU不再需要不停轮询
缺点：每个字在I/O设备与内存之间的传输需要经过CPU；频繁中断影响效率

3. DMA方式

Direct Memory Access，直接存储器存取，主要用于块设备的I/O控制
CPU指明此次要进行的操作，说明读/写多少数据，数据存在内存什么位置、数据在外部设备上的地址
控制器会根据CPU提出的要求完成数据的读/写工作，整块数据的传输完成后，才向CPU发出中断信号

• CPU通过系统总线读/写寄存器中的内容
• DMA控制器通过系统总线直接和内存相连，可以不需要CPU中转
• 当DMA完成整个过程后才会给CPU发出相应信号，CPU再介入进行后续处理
• 数据寄存器DR：暂存从设备到内存或从内存到设备的数据
• 内存地址寄存器MAR：输入时，MAR表示数据应放到内存中的什么位置；输出时，MAR表示要输出的数据放在内存中的什么位置
• 数据计数器DC：表示剩余要读/写的字节数
• 状态寄存器CR：用于存放CPU发来的I/O命令或设备的状态信息

1.CPU干预频率：
仅在传送一个或多个数据块的开始和结束时，才需要CPU干预

2.数据传送单位：
每次读/写一个或多个块(每次读写的只能是连续的多个块，在内存中也必须是连续的

3.数据流向：
读：I/O设备->内存
写：内存->I/O设备

优点：数据传输以"块"为单位，CPU介入频率进一步降低。数据传输不再需要先经过CPU再写入内存，数据传输效率有所提高。CPU和I/O设备并行性得到提升
缺点：CPU每发出一条I/O指令，只能读/写一个或多个连续数据块

4. 通道控制方式

通道是专门用来处理I/O请求的硬件，可执行的指令很单一，并且通道程序是放在主机内存中的，通道与CPU共享内存，可看作是功能单一的小CPU
一个通道可以控制多个I/O控制器(反馈当前设备状态)；一个I/O控制器可以控制多个设备

1.CPU干预频率：
极低，通道会根据CPU指示执行相应的通道程序，只有完成一组数据块的读/写后才需要发出中断信号，请求CPU干预

2.数据传送单位：
每次读/写一组数据块

3.数据的流向(在通道下进行)：
读：I/O设备->内存
写：内存->I/O设备

优点：资源利用率高，与DMA相比一次CPU干预可以执行更多操作
缺点：实现复杂，需要专门的通道硬件支持

3、I/O软件层次结构

用户通过软件与硬件进行交互

①越上层越接近用户

②每一层会利用其下层提供的服务，实现某些功能，并屏蔽实现的具体细节，向高层提供服务(封装)

③越下层越接近硬件

• 用户层软件：实现了与用户交互的接口，用户可直接使用该层提供的、与I/O操作相关的库函数对设备进行操作
• 设备独立性软件(系统调用处理层)：用户层软件将用户请求翻译成格式化I/O请求，并通过"系统调用"请求操作系统内核的服务。通过"逻辑设备表LUT"来确定逻辑设备对应的物理设备，并找到该设备对应的设备驱动程序
• 设备驱动程序：主要负责对硬件设备的具体控制，将上层发出的一系列命令转化为特定设备"听得懂"的一系列操作(每个设备都有自己的语言，驱动是翻译)。包括设置设备寄存器；检查设备状态等，驱动程序一般以一个独立进程的方式存在
• 中断处理程序：当I/O任务完成时，I/O控制器会发送一个中断信号，系统会根据中断信号找到相应的中断处理程序执行(如设备正忙碌则让进程阻塞；设备空闲则读入一个字)
• 硬件：执行I/O操作，由机械部件、电子部件组成
• 直接涉及到硬件具体细节的且与中断无关的操作肯定是在设备驱动程序层完成的；没有涉及硬件的、对各种设备都需要进行管理工作都是在设备独立性软件层完成的

4、I/O核心子系统

设备独立性软件、设备驱动程序、中断处理程序属于操作系统内核部分，即I/O核心子系统

1. I/O调度

属于设备独立性软件的一部分，即用某种算法确定一个好的顺序处理各个I/O请求(如先来先服务、优先级算法)

2. 设备保护

属于设备独立性软件的一部分。在UNIX系统中，设备被看作是特殊的文件，每个设备有对应的FCB。当用户请求访问某个设备时，系统根据FCB中记录的信息来判断该用户是否有相应的访问权限，以此实现设备保护

3. 缓冲区管理

缓冲区是一个存储区域，可以由专门的硬件寄存器组成，也可以利用内存作为缓冲区
使用硬件作为缓冲区的成本较高，容量也比较小(Cache)，一般仅用在对速度要求非常高的场合
更多的是利用内存作为缓冲区，"设备独立性软件"的缓冲区管理就是要组织管理好这些缓冲区

作用

• 缓和CPU与I/O设备之间速度不匹配的矛盾
• 减少对CPU的中断频率，放宽对CPU中断相应时间的限制(缓冲区找到就不用去看I/O状态，也就减少中断可能)
• 解决数据粒度不匹配的问题(如进程每次生成1块数据，但I/O设备每次只能输出一个字符)
• 提高CPU与I/O设备之间的并行性

当缓冲区数据非空时，不能往缓冲区存入数据，只能从缓冲区把数据传出；当缓冲区为空时，可以往缓冲区存入数据，但是必须把缓冲区充满以后才能从缓冲区把数据拿走

若题目没有特别说明，一个缓冲区的大小就是一个块，因此块设备传输时一定是会填满缓冲区的，要么全空，要么全满，不会存在填了一般缓冲区的情况

单缓冲

只有一个缓冲区，处理一块数据的平均耗时MAX(C,T)+M

假设T>C(另外两种情况同理)

1. 起初缓冲区为空，工作区为空，T时间注入
2. 此时缓冲区为满，因此无法输入，只有传送时间M
3. 此时用户进程为满，可以处理C，无法传送，但是缓冲区为空，可以输出T，此时同时进行两步
4. 总之，由于一个缓冲区，因此T和M不会同时出现，M和C不会同时出现

双缓冲

两个缓冲区，处理一块数据的平均耗时MAX(C+M,T)

1. 当M+C1，传完后又可以继续给缓冲区2，T一直无缝衔接
2. M与C需要交替进行
3. 当M+C>T时，起初全空时，块设备先输入T给缓冲区1，传完后又可以继续输入T给缓冲区2。但是缓冲区2传完后发现缓冲区1的M+C还没有结束，即此时缓冲区1不空，而缓冲区2又是满，没有其他缓冲空间了，所以块设备必须等到到缓冲区1的M+C结束才可以把内容输入T到缓冲区1及缓冲区2传送M到工作区

缓冲池

缓冲池由系统中共用的缓冲区组成。
其中hin、sout、sin、hout都是缓冲区，队列取出后经过他们与设备或用户程序交互

• emq空缓冲队列：用于取出空缓冲区来进行读写等操作
• inq输入队列：用来记录输入设备输入的数据，以便用户程序读取。
• outq输出队列：用来记录用户程序输出到设备(显示屏或是文件等)的数据，以便用户程序读取。
• 收容输入：把设备输入的数据放在缓冲区中
• 提取输入：把缓冲区的数据交给用户程序处理。
• 收容输出：把用户程序处理完的数据放在缓冲区中。
• 提取输出：把缓冲区的数据交给设备

第七章 文件管理

什么是文件？
文件就是一组有意义的信息/数据集合

文件有哪些属性？

• 文件名：由创建文件的用户决定文件名，主要是为了方便用户找到文件，同一目录下不允许有重名文件。
• 标识符：操作系统用于区分各个文件的一种内部名称(用户见不到)
• 类型：指明文件的类型
• 位置：文件存放的路径(让用户使用)、在外存中的地址(硬件地址，对用户不可见)
• 大小：指明文件大小
• 保护信息：对文件进行保护的访问控制信息(权限)

文件内部数据如何组织起来？

• 无结构文件：由一些二进制或字符流组成，又称"流式文件"
• 有结构文件(数据库表)：由一组相似的记录组成，又称"记录式文件"。记录是一组相关数据项的集合，数据项是文件系统中最基本的数据单位

操作系统向上提供哪些功能？

• 创建文件(create系统调用)
• 删除文件(delete系统调用)
• 读文件(read系统调用)
• 写文件(write系统调用)
• 打开文件(open系统调用)
• 关闭文件(close系统调用)