第 1 章计算机系统概述

408 操作系统第 1 章计算机系统概述复习讲义，涵盖核心概念、重点考点与典型题型。

先把全章压缩成一条主线：

为什么需要操作系统
        ↓
管理 CPU、内存、文件、设备
        ↓
支持多个程序并发、共享资源
        ↓
但普通程序不能随便操作硬件
        ↓
因此区分 用户态 / 内核态
        ↓
通过 中断 / 异常 / 系统调用 进入内核
        ↓
内核完成资源管理
        ↓
宏内核、微内核等决定“内核怎么组织”
        ↓
开机时通过引导过程把 OS 装入内存
        ↓
虚拟机进一步把一台物理机器虚拟成多台逻辑机器

这就是第一章真正要建立的整体框架。

一、1.1 操作系统的基本概念

1. 操作系统到底是什么？

资料给出的核心定义可以拆成三件事：

操作系统是控制和管理计算机软硬件资源、合理调度任务与分配资源，并为用户及其他软件提供统一接口和运行环境的最基本系统软件。

从层次看：

用户
 ↑
应用程序
 ↑
操作系统 OS
 ↑
CPU、内存、磁盘、键盘、网卡……

所以 OS 最重要的角色，不是 Windows 的桌面、开始菜单这些 GUI。

GUI 只是操作系统提供的一种用户接口。

真正的核心是：

向下管理硬件，向上提供抽象。

例如你写：

read(fd, buf, 100);

程序不需要知道：

磁盘磁头怎么动；
SSD 控制器怎么工作；
DMA 怎么传输；
哪个磁盘块保存文件；
其他程序是否也在读磁盘。

这些都由操作系统处理。

所以可以把 OS 理解为：

硬件资源的总管理员 + 应用程序的运行平台。

二、操作系统的三大角色

1. 资源管理者

这是最重要的一层。

操作系统主要管理四类资源：

资源	OS 负责什么	后续章节
CPU	进程控制、调度、同步、通信、死锁	第2章
内存	分配回收、地址映射、保护、共享、扩充	第3章
文件	目录、文件读写、空间分配、保护	第4章
设备	I/O、驱动、缓冲、设备分配、虚拟设备	第5章

这实际上就是整本操作系统教材的结构。

因此第一章相当于告诉你：

后面四章其实就是把“OS 管理四类资源”逐个展开。

三、操作系统向用户提供什么接口？

这是经典选择题。

操作系统提供两大类接口：

              操作系统接口
              /        \
         用户接口      程序接口
                     = 系统调用

1. 用户接口

主要有：

联机命令接口；
脱机作业接口；
图形用户接口 GUI。

例如：

Linux Shell
Windows CMD
Windows 图形桌面

主要面向人。

2. 程序接口——系统调用 ★★★★★

应用程序与操作系统之间真正的接口是：

系统调用 System Call

2010 年真题直接考过：

操作系统提供给应用程序的接口是什么？

答案就是：

系统调用。

不是：

中断；
库函数；
原语。

四、系统调用 ≠ 库函数

这是第一章最容易混淆的地方之一。

例如：

printf("hello");

printf() 是：

C 标准库函数。

它不是操作系统直接提供的系统调用。

它最终可能调用：

write()

而 write 才是真正请求操作系统服务的系统调用。

可以理解成：

你的程序
 ↓
printf()
 ↓
C 库
 ↓
write 系统调用
 ↓
操作系统内核
 ↓
设备

但是，并非所有库函数都需要系统调用。

例如：

strlen()
sqrt()

可能完全在用户态完成。

所以一定记：

库函数可能调用系统调用，也可能不调用；系统调用才是 OS 给应用程序提供的程序接口。

五、操作系统作为“扩充机器”

裸机只有：

CPU
内存
磁盘
I/O设备

硬件本身其实很难用。

例如磁盘给你的只是：

扇区
块
控制寄存器

但 OS 把它抽象成：

C:\Users\xxx\a.txt

又比如物理内存本来只有若干 GB，OS 给每个进程提供：

独立的虚拟地址空间。

CPU 只有几个核心，但你可能同时：

浏览网页；
听音乐；
下载文件；
写代码。

感觉每个程序都有自己的 CPU。

这就是 OS 的：

抽象和虚拟化能力。

六、操作系统四个基本特征 ★★★★

资料总结为：

并发、共享、虚拟、异步。

其中：

并发和共享是最基本的两个特征，而且互为存在条件。

1. 并发 Concurrency

并发：

多个事件在同一个时间段内发生。

例如单核 CPU：

0~10ms    程序 A
10~20ms   程序 B
20~30ms   程序 C
30~40ms   程序 A

一秒钟切换几百次。

人看起来：

A、B、C 同时运行

实际上任意一个瞬间：

只有一个程序真正执行。

这叫并发。

七、并发和并行 ★★★★★

408 经常拿这两个词设坑。

并发

强调：

同一时间段。

并行

强调：

同一时刻。

例如：

单核 CPU

进程 A ──┐
         ├─交替运行 → 并发
进程 B ──┘

双核 CPU

CPU0 → A
CPU1 → B

A、B 可以真正同时运行。

这叫：

并行。

真题思路

2009 真题问：

单处理机系统中哪些可以并行？

进程与进程不能真正并行，但：

CPU 与设备；
CPU 与通道；
设备与设备；

可以。

所以答案是：

II、III、IV。

这道题非常重要，因为它说明：

“单处理机”不意味着整个计算机所有部件都只能串行。

多个并发进程可以共同使用系统资源。

分两种。

1. 互斥共享

某个资源一次只能给一个进程使用。

例如：

打印机。

如果两个进程同时直接打印：

进程A：操作系统
进程B：高等数学

可能打印成：

操高作等系数统学……

因此必须：

A 使用
↓
A 释放
↓
B 使用

这种资源叫：

临界资源。

2. 同时访问

例如：

两个程序读取同一个只读文件。

它们可以宏观上同时访问。

注意“同时访问”不一定意味着物理设备在同一个纳秒真正处理两个请求。

很多情况下还是：

分时访问。

九、为什么“并发”和“共享”互为条件？

这个逻辑非常重要。

如果没有并发：

永远只有一个程序运行

那就不存在：

多个程序竞争同一资源。

所以不需要共享机制。

反过来：

如果多个程序并发执行，却没有正确的共享机制：

A 修改 x
B 也修改 x

结果可能混乱。

因此：

并发导致共享需求，而正确的共享机制又是并发正确运行的基础。

十、虚拟 Virtual

虚拟的本质：

把一个物理资源变成多个逻辑资源，或者把有限资源表现成更大的逻辑资源。

主要两类思想。

1. 时分复用

例如：

一个 CPU
↓
A 用 10 ms
B 用 10 ms
C 用 10 ms

每个程序感觉：

“我好像有自己的 CPU。”

2. 空分复用

典型：

虚拟内存。

例如物理内存：

8 GB

一个程序看到的虚拟地址空间却可能远大于此。

3. 虚拟设备

例如：

SPOOLing 打印技术。

物理上只有：

1 台打印机

但是系统可以为不同用户建立：

逻辑打印设备 A
逻辑打印设备 B
逻辑打印设备 C

后台再排队真正打印。

十一、异步 Asynchronism

多道程序环境下，一个程序可能：

运行
↓
等待 I/O
↓
暂停
↓
I/O 完成
↓
重新运行
↓
被抢占
↓
再次运行

因此其运行速度：

不可预知。

这就是异步。

注意：

异步 ≠ 结果随机。

只要同步机制设计正确，程序仍应得到正确结果。

十二、1.2 操作系统的发展历程

这一部分不用死背年代，核心是理解：

每一种新系统为什么出现？

可以记成一条“解决矛盾”的历史线。

人工操作
↓
CPU 老等人
↓
脱机 I/O
↓
仍然一次只能运行一道程序
↓
单道批处理
↓
CPU 等 I/O
↓
多道批处理
↓
缺少人机交互
↓
分时系统
↓
某些任务必须保证截止时间
↓
实时系统

十三、手工操作阶段

最早没有 OS。

程序员需要：

放入纸带
↓
装入程序
↓
人工启动
↓
等待运行
↓
人工输出

最大问题：

CPU 太快，人和 I/O 太慢。

CPU 大量时间都在：

等……

因此利用率极低。

十四、脱机 I/O

解决：

CPU 等待慢速输入输出的问题。

增加一台外围机。

输入：

纸带
↓
外围机
↓
磁带
↓
主机

输出类似。

重点理解：

脱机 I/O 的“脱机”是指 I/O 操作不由主机 CPU 直接控制。

十五、单道批处理系统

一批作业预先提交：

作业1
作业2
作业3
...

监督程序自动：

执行1
↓
执行2
↓
执行3

优点：

不用用户反复人工干预。

但最大的缺点：

内存中始终只有一道用户程序。

于是：

程序运行
↓
发起 I/O
↓
CPU 等待
↓
I/O 完成
↓
CPU 再运行

CPU 还是经常空闲。

十六、多道批处理系统 ★★★★

于是出现：

多道程序设计。

内存同时放：

程序 A
程序 B
程序 C

当：

A → 等待磁盘

CPU 可以：

执行 B

当 B 等打印机：

CPU → 执行 C

这样就能让：

CPU；
磁盘；
其他 I/O；

尽可能同时忙。

多道程序三个典型特征

多道

内存中同时存在多个程序。

宏观上并行

大家都“在执行过程中”。

微观上串行

单核 CPU 某一个瞬间只执行一个。

多道程序系统主要好处

真题 2017 考过：

与单道系统相比，多道程序系统具有：

CPU 利用率提高；
I/O 设备利用率提高；
吞吐量提高。

但：

系统开销并不会更小。

因为还需要：

调度；
切换；
内存保护；
同步；
资源管理。

十七、一个非常重要的陷阱

很多人会认为：

“内存里进程越多，CPU 利用率一定越高。”

错误。

一开始增加进程数确实可能提高利用率。

但过多之后会导致：

内存压力；
大量换入换出；
页面频繁置换；
调度开销增加。

严重时甚至产生：

抖动。

因此 2022 真题就考了：

“进程数越多，CPU 利用率越高”

这是错误表述。

十八、分时操作系统

多道批处理系统解决了：

CPU 利用率。

但人不能很好地和程序交互。

于是出现分时系统。

基本思想：

把 CPU 时间划分成很多时间片。

例如每人 10ms：

用户A 10ms
用户B 10ms
用户C 10ms
用户A 10ms
...

CPU 很快，人会感觉：

自己独占一台计算机。

分时系统四个特征

可以记：

多、交、独、及

即：

多路性；
交互性；
独立性；
及时性。

十九、实时操作系统

核心不是“非常快”。

而是：

规定时间内必须响应。

这一点极其重要。

硬实时

截止时间：

绝对不能错过。

比如资料列举的：

飞机控制；
导弹制导。

软实时

偶尔超过截止时间：

可以容忍。

例如某些业务处理系统。

二十、批处理、分时、实时怎么区分？

做题时抓关键词即可：

题干关键词	系统
自动成批处理、吞吐量	批处理
多终端、人机交互、时间片	分时
截止时间、确定性	实时
多机协同、位置透明	分布式

资料也明确建议按这种描述来辨析，而不是死背发展年代。

二十一、网络 OS 和分布式 OS

两者都可能有很多计算机。

区别非常重要。

网络操作系统

每台机器基本还是：

独立计算机。

访问远程资源时，你通常知道：

这是另一台机器的文件
这是远程服务器

分布式系统

目标是：

让很多机器看起来像“一台系统”。

强调：

透明性。

用户尽量不需要知道任务到底在哪台机器执行。

二十二、1.3 操作系统运行环境 ★★★★★

这一节是整个第一章最重要的部分。

真题从 2009 到 2024 几乎连续出现：

2009 外中断；
2010 系统调用接口；
2011 用户态；
2012 进程切换、PSW；
2013 用户态→内核态；
2014 特权指令；
2015 中断现场；
2017 系统调用顺序；
2018 时钟中断；
2019 系统调用性质；
2021 特权指令、创建进程；
2022 CPU 模式、系统调用处理；
2023/2024 中断和系统调用继续出题。

因此这部分必须真正理解。

二十三、为什么必须有用户态和内核态？

假设所有程序权限一样。

一个普通程序就可以执行：

关闭中断
修改页表
任意读写内存
直接控制磁盘
修改系统时钟

那么恶意程序甚至一个普通 bug 都能让整个系统崩溃。

所以 CPU 必须提供权限等级。

教材主要讲两级：

用户态
内核态

二十四、用户态和内核态 ★★★★★

项目	用户态	内核态
又称	目态	管态/系统态
权限	低	高
用户程序	是	通常否
内核程序	否	是
特权指令	不能	可以
非特权指令	可以	可以

最容易错的是：

内核态不是“只能执行特权指令”。

内核态是：

特权指令和非特权指令都能执行。

用户态则：

只能执行非特权指令。

2022 真题就专门考这个。

二十五、什么是特权指令？ ★★★★★

特权指令：

会影响整个系统安全、状态或关键资源，因此只允许内核执行。

典型例子：

I/O 指令；
关中断；
修改系统时钟；
修改内存管理相关寄存器；
修改处理器状态。

一个经典陷阱：trap 指令

很多人认为：

trap 会进入内核，所以 trap 必须是特权指令。

错误。

如果 trap 本身不能在用户态执行，那么：

用户程序怎么请求系统调用？

所以：

trap/访管指令必须允许用户程序执行。

其作用恰恰就是：

用户态执行 trap
↓
CPU 进入内核态

2014、2021 真题都考过类似逻辑。

二十六、用户态 → 内核态有哪几种原因？

掌握这一张图：

                用户态
                  │
       ┌──────────┼───────────┐
       │          │           │
    系统调用     异常       外中断
       │          │           │
       └──────────┼───────────┘
                  ↓
                内核态

例如：

系统调用

read()
write()
fork()

异常

除零
缺页
地址越界
非法指令

外中断

键盘输入
磁盘完成
时钟到期

二十七、真题：哪些会让用户态切换到内核态？

2013 真题：

I. 整数除零 II. sin() 函数调用 III. read 系统调用

分析：

I 整数除零

发生异常：

用户态 → 内核态

所以会。

II sin()

普通数学库函数：

用户态 → 用户态

通常不进入内核。

III read()

系统调用：

用户态 → 内核态

所以会。

答案：

I、III。

二十八、操作系统内核

内核是：

操作系统最核心、最底层、最需要特权支持的部分。

常驻内存。

资料把主要功能概括为两类。

支撑功能

主要包括：

时钟管理；
中断机制；
原语。

资源管理

包括：

进程管理；
存储器管理；
设备管理等。

二十九、时钟管理 ★★★

别把时钟理解为：

“右下角显示几点”。

真正重要的是：

时钟中断。

CPU 每隔一段时间收到时钟中断。

例如：

A 获得 10 ms 时间片
↓
10 ms 到
↓
时钟中断
↓
进入内核
↓
更新时间
↓
检查时间片
↓
必要时调度 B

时钟中断会更新什么？

2018 真题直接考：

I. 内核时钟变量 II. 当前进程已使用 CPU 时间 III. 当前进程剩余时间片

答案：

三者都可能更新。

所以时钟机制是：

计时；
调度；
超时控制；

的基础。

三十、什么是原语？

原语：

由若干条指令组成、完成某个特定功能，执行过程中具有原子性。

核心：

不允许做到一半留下系统处于不一致状态。

例如系统要改变：

PCB 状态

假设操作做到一半就被中断：

PCB 一半旧数据
PCB 一半新数据

可能直接破坏 OS 内部结构。

所以这类关键操作要具有：

原子性。

三十一、中断和异常 ★★★★★

这是本章第一大高频点。

最重要的区分：

来源。

中断 Interrupt

狭义上也叫：

外中断。

来自：

CPU 正在执行的指令之外。

例如：

键盘输入；
网卡收到数据；
磁盘 I/O 完成；
时钟中断。

异常 Exception

又叫：

内中断。

来自：

当前指令执行过程中。

例如：

除零；
缺页；
地址越界；
非法指令；
溢出；
trap。

三十二、最简单的判断法

问自己：

“如果 CPU 不执行当前这条指令，这个事件还可能发生吗？”

例如：

键盘按键

即使 CPU 正在执行其他程序：

键盘仍然可以被按。

所以：

外中断。

除零

只有 CPU 执行：

10 / 0

才发生。

所以：

异常。

缺页

CPU 执行某条访存指令：

访问虚拟地址 X

发现页面不在内存。

所以：

异常。

三十三、中断分类

资料采用：

外中断
├─ 可屏蔽中断 INTR
└─ 不可屏蔽中断 NMI

可屏蔽中断

可以通过中断控制机制暂时屏蔽。

例如：

一般 I/O 请求。

不可屏蔽中断

通常用于：

极其严重的硬件事件。

例如：

电源问题；
严重硬件故障。

三十四、异常三种类型 ★★★★★

异常
├─ Fault 故障
├─ Trap 自陷
└─ Abort 终止

1. Fault——故障

特点：

有可能修复。

处理之后往往：

重新执行原指令。

最典型：

缺页异常。

例如：

MOV R1,[地址 X]

发现页不在内存：

缺页
↓
进入内核
↓
把页面调入内存
↓
重新执行 MOV

所以：

Fault 往往回到原指令。

三十五、Trap——自陷

通常是：

有意安排的异常。

最典型：

系统调用。

例如：

执行 trap
↓
进入 OS
↓
完成 read()
↓
返回 trap 的下一条指令

所以：

Trap 通常返回下一条指令。

三十六、Abort——终止

表示：

严重错误，通常难以恢复。

例如资料列出的严重硬件故障。

一般：

不能简单重新执行原指令。

三十七、一张表记住

类型	来源	能否恢复	返回位置
Fault	指令执行故障	常可恢复	原指令
Trap	有意陷入	可	下一指令
Abort	严重故障	通常不可	通常终止

这是非常好用的选择题判断框架。

三十八、中断/异常发生后到底发生什么？ ★★★★★

这是第二个一定要理解的“过程”。

可以抽象成：

① 发生中断/异常
↓
② CPU 停止正常用户程序控制流
↓
③ 保存断点和关键处理器状态
↓
④ 进入内核态
↓
⑤ 根据中断/异常类型找到处理程序
↓
⑥ 执行处理中断/异常
↓
⑦ 必要时进行调度
↓
⑧ 恢复现场
↓
⑨ 返回原程序或其他进程

三十九、谁负责保存什么？——非常容易考

要区分：

硬件自动完成

和

操作系统软件完成。

典型思想：

CPU / 硬件必须首先保存

保证它能够安全进入中断处理程序所必需的最小状态，例如：

PC；
PSW。

操作系统进一步保存

例如：

通用寄存器等完整上下文。

为什么 PSW 特别重要？

2012 真题：

中断处理与普通子程序调用都需要保护现场，中断一定保存而普通子程序调用不一定保存什么？

答案：

程序状态字 PSW。

因为中断可能改变：

CPU 模式；
中断状态；
条件码等系统状态。

普通函数调用没有这个必然要求。

四十、Cache 和 TLB 要不要每次中断都保存？

一般选择题不要看到：

“中断来了把 CPU 所有东西全部复制保存”

就认为正确。

例如真题曾给：

PC；
通用寄存器；
TLB；
Cache。

操作系统真正需要保存的是：

进程继续执行所必需的逻辑现场。

Cache/TLB 是硬件加速结构，并不是简单“整个保存下来”。

四十一、系统调用 ★★★★★

系统调用的本质：

用户程序主动请求内核提供服务。

注意“主动”。

和设备中断不同：

系统调用：程序主动
外中断：外部设备主动
异常：执行当前指令时发现问题

四十二、为什么不能直接让用户程序调用内核函数？

假设用户程序能随便：

jump kernel_function

那么它可能：

跳过权限检查；
构造非法地址；
修改关键系统数据。

所以系统调用必须有：

受控入口。

四十三、系统调用的典型类型

资料列出：

设备管理；
文件管理；
进程控制；
进程通信；
内存管理。

例如：

open
read
write
fork
exit
mmap

都属于这类思想。

四十四、系统调用完整执行过程 ★★★★★

这是本章必须会默写的流程。

假设用户程序调用：

read(fd, buf, n);

第一步：准备参数

用户程序准备：

系统调用号；
fd；
buf；
n。

通常通过：

寄存器；
内存；
栈；

等方式传递。

第二步：执行陷入指令

例如抽象成：

trap

此时发生：

用户态
↓
内核态

第三步：保存现场

CPU/内核保存必要信息。

例如：

PC；
PSW；
通用寄存器。

第四步：根据系统调用号找到服务例程

例如：

syscall number = read

于是查询：

系统调用表

找到：

sys_read

第五步：执行内核服务

内核：

检查参数；
检查权限；
找文件对象；
必要时发起设备 I/O。

第六步：返回

恢复现场：

内核态
↓
用户态

程序继续执行。

资料概括的顺序就是：

传递参数
↓
执行 trap
↓
执行服务程序
↓
返回用户态

四十五、2017 真题：系统调用顺序

给：

I. 返回用户态 II. trap III. 传参数 IV. 服务程序

正确顺序：

III \to II \to IV \to I

也就是：

准备参数
→ trap
→ 内核服务
→ 返回用户态

这是必须记牢的。

四十六、硬件和操作系统分别干什么？ ★★★★★

这是 2022 真题很喜欢的角度。

系统调用发生：

硬件负责

关键的底层特权转换，例如：

保存必要 PC / PSW
切换处理器模式
找到预设入口

操作系统负责

进入内核后进一步：

保存通用寄存器
解析系统调用
执行服务例程
资源管理
恢复软件现场

因此：

CPU 模式切换本身不是用户程序随便修改一个 mode 位，而是受硬件机制控制。

四十七、系统调用与普通函数调用

	普通函数	系统调用
是否进入内核	通常否	是
是否改变 CPU 特权级	否	是
调用方式	call / jump	trap / syscall
被调用代码	用户程序	内核
开销	较小	较大

所以：

sin(x)

和：

read(fd,...)

本质完全不同。

四十八、一个极重要结论

不要认为：

“系统调用一定发生进程切换。”

错误。

系统调用一定会：

用户态 → 内核态。

但不一定：

进程 A → 进程 B。

例如：

A 调用 getpid()
↓
内核返回结果
↓
仍然继续运行 A

只发生：

模式切换。

没有发生：

进程切换。

这是后面进程章节也会反复用到的思想。

四十九、程序链接、装入与运行时内存映像

你这份第 1 章资料的考纲列出了：

程序链接与装入；
程序运行时内存映像；
地址空间。

但资料明确注明：

这些内容将在第 3 章 3.1 节具体展开。

因此本章目前只需先建立位置感：

源程序
↓
编译 / 汇编
↓
目标模块
↓
链接
↓
可执行文件
↓
装入
↓
进程地址空间
↓
CPU 执行

链接、装入方式以及：

代码段
数据段
堆
栈
虚拟地址空间

等，在存储管理部分再系统展开更合适。

五十、1.4 操作系统结构 ★★★★

这一节的核心问题：

操作系统那么多功能，到底怎么组织？

主要讲：

分层
模块化
宏内核
微内核
外核

五十一、分层法

结构：

层 N  用户接口
 ↑
层 ...
 ↑
层 2
 ↑
层 1
 ↑
层 0  硬件

每层主要依赖下层。

优点

易验证

可以：

先验证层1
↓
再验证层2
↓
再验证层3

易维护

某层内部改变，只要：

对外接口不变

上层不必修改。

缺点

很难划分层次

OS 功能互相依赖。

例如：

文件系统
↓
需要磁盘
↓
又需要内存缓存
↓
又可能触发进程阻塞

很难严格说它只属于某一层。

性能开销

如果调用：

层6
→层5
→层4
→层3
→层2
→层1

中间开销较大。

五十二、模块化

不是强调上下层，而是：

按功能拆模块。

例如：

进程管理模块
内存管理模块
文件系统模块
设备模块

模块间通过：

明确接口。

好的模块设计追求：

高内聚、低耦合。

分层 vs 模块化

最简单区分：

分层

强调：

谁在上、谁在下。

模块化

强调：

功能怎么拆。

五十三、宏内核 Monolithic Kernel ★★★★★

核心思想：

把操作系统的大部分核心服务都放进内核态。

例如：

内核
├─ 调度
├─ 内存管理
├─ 文件系统
├─ 网络
└─ 设备驱动

都在：

内核地址空间。

最大优点

快。

因为模块可以直接函数调用：

文件系统
↓
直接调用设备驱动

不需要频繁跨用户态/内核态传消息。

最大缺点

内核巨大、耦合高。

一个驱动 bug：

非法访问内存

可能导致：

整个系统崩溃。

资料把 Linux 等归于宏内核或以宏内核思想为主的系统。

五十四、微内核 Microkernel ★★★★★

微内核思想恰好相反：

内核里只保留最必要的机制。

例如：

基本调度；
IPC；
中断/陷入；
最基本地址空间机制。

而：

文件系统；
驱动；
其他系统服务；

尽量放到：

用户态服务器。

结构

应用程序
  │
  ├──消息──→ 文件服务器
  │
  ├──消息──→ 驱动服务器
  │
  └──消息──→ 网络服务器
             │
          微内核
             │
            硬件

五十五、为什么微内核可靠？

假设声卡驱动崩溃。

宏内核

驱动在内核态：

驱动崩
↓
可能破坏整个内核
↓
系统崩溃

微内核

驱动可能只是一个用户态服务进程：

驱动服务崩
↓
重启这个服务

未必拖垮整个系统。

所以微内核一般具有：

可靠性高；
安全性高；
扩展性好。

五十六、微内核为什么慢？

因为很多操作变成：

应用程序
↓
微内核
↓
服务器
↓
微内核
↓
应用程序

需要：

IPC；
上下文切换；
地址空间切换；
消息复制。

所以：

性能通常不如宏内核。

2023 真题就考：

微内核相对宏内核：

较高可靠性；
较高安全性；
较强扩展性；

但通常不是：

较好性能。

答案为：

II、III、IV。

五十七、微内核的四个思想

资料还总结了：

小内核；
客户/服务器；
机制与策略分离；
面向对象思想。

其中最重要的是：

机制与策略分离。

什么是机制？

回答：

“系统能不能做到？”

例如：

能进行进程切换。

什么是策略？

回答：

“具体怎么选？”

例如：

使用时间片轮转还是优先级调度？

因此微内核倾向于：

内核提供机制
上层决定策略

五十八、外核 Exokernel

外核思想更激进。

传统 OS：

硬件
↓
OS 抽象
↓
文件
虚拟内存
进程
↓
程序

外核认为：

不要强迫所有程序接受同一套高层抽象。

所以外核主要负责：

保护和分配物理资源。

至于：

文件系统怎么做；
内存怎么组织；
调度怎么设计；

可以交给用户级：

Library OS。

核心记忆

宏内核

我全给你管。

微内核

我只保留最核心服务。

外核

我主要保证资源安全，具体怎么用你自己决定。

资料强调外核在考研中通常不需要钻太深，记住“暴露资源 + 保护隔离 + 用户级抽象”即可。

五十九、三者比较 ★★★★★

	宏内核	微内核	外核
内核内容	多	少	更偏资源保护
文件系统	常在内核	常在用户态服务器	可由 Library OS 实现
驱动	常在内核	可移到用户态	用户级定制空间更大
性能	高	相对低	可高度优化
可靠性	相对低	高	隔离较强
灵活性	一般	高	很高

六十、题库里的一个典型微内核陷阱

题库有一项：

“微内核通过进程间通信，因此性能优于宏内核。”

错误。

恰恰因为：

IPC 和模式切换更多，

通常性能反而：

不如宏内核。

题库还专门考：

UNIX 属于微内核。

这种说法也是错误的。

六十一、1.5 操作系统引导 ★★★★

一个非常好的理解问题：

操作系统本身存在硬盘里，那么开机时是谁把操作系统从硬盘读出来？

不能回答：

“操作系统自己。”

因为此时 OS 还没运行。

这就需要：

引导程序。

六十二、经典 BIOS/MBR 启动链

按照资料中的传统启动过程：

通电
↓
CPU 开始执行 BIOS
↓
硬件自检 POST
↓
选择启动设备
↓
读取 MBR
↓
寻找活动分区
↓
读取 PBR
↓
加载启动管理器
↓
加载操作系统内核
↓
内核进入 RAM 并开始运行

六十三、第一步是什么？

题库直接问：

BIOS 引导的第一步是什么？

答案：

硬件自检 POST。

不是：

读 MBR；
读分区；
加载内核。

这些都在后面。

六十四、MBR 是什么？

主引导记录：

Master Boot Record。

位于启动磁盘首部的传统引导区域。

主要含：

引导代码；
分区信息。

它的任务不是直接完整加载整个 Windows/Linux。

它更多是：

找到下一阶段
↓
继续启动

六十五、PBR

分区引导记录：

Partition Boot Record。

MBR 找到活动分区后：

加载该分区 PBR

PBR 再继续：

加载真正的启动管理程序。

六十六、启动管理器

例如资料提到：

GRUB
Bootmgr

启动管理器最终负责：

定位并装入 OS 内核。

六十七、操作系统最终装到哪里？

2013 真题：

开机后操作系统最终装到哪里？

答案：

RAM。

不是：

BIOS；
ROM；
EPROM。

因为 CPU 正常执行内核程序时：

内核必须进入主存。

六十八、一个容易混的题

题库问：

引导扇区中的引导代码是谁写进去的？

答案：

操作系统安装时由安装程序/引导工具写入。

不是 BIOS 每次开机临时写进去。

BIOS 的职责是：

读取和执行。

六十九、1.6 虚拟机 ★★★

虚拟机的本质：

在一台物理计算机上构造多台逻辑计算机。

例如：

Windows
├─ Ubuntu VM
├─ Windows VM
└─ Linux VM

每个虚拟机认为：

“我有自己的 CPU、内存、磁盘、网卡。”

实际硬件只有一套。

虚拟机管理程序：

VMM / Hypervisor

负责把真实资源分配给它们。

七十、第一类虚拟机管理程序 Type 1

又称：

裸金属虚拟化。

结构：

虚拟机1      虚拟机2
   ↓            ↓
客户OS1      客户OS2
     \        /
       VMM
        ↓
      硬件

VMM：

直接运行在物理硬件上。

不存在普通宿主 OS 夹在中间。

七十一、第二类虚拟机管理程序 Type 2

又叫：

寄居型。

例如资料以 VMware Workstation 为例：

Ubuntu VM
↓
VMware Workstation
↓
Windows
↓
物理硬件

这里：

Windows 是：

宿主操作系统 Host OS。

Ubuntu 是：

客户操作系统 Guest OS。

七十二、Type 1 和 Type 2 一句话区别

Type 1

VMM
↓
硬件

直接管硬件。

Type 2

VMM
↓
宿主 OS
↓
硬件

依赖宿主 OS。

七十三、虚拟化最难理解的一点：客户 OS 以为自己是内核

例如虚拟机中的 Linux 执行：

特权指令

Linux 以为：

“我是操作系统，我有最高权限。”

但真正物理机器的最高控制者是：

VMM。

因此硬件/VMM 会截获敏感操作：

Guest OS
↓
执行敏感指令
↓
陷入 VMM
↓
VMM 模拟执行
↓
返回 Guest OS

于是 Guest OS 感觉：

自己真的控制了硬件。

资料把虚拟化核心概括得很好：

隔离、伪装、管理。

七十四、第 1 章真题频率怎么分配复习时间？

根据你资料中整理的 2009—2024 真题，建议这样排优先级。

S 级：必须真正理解

1 中断 / 异常

要会：

外中断 vs 异常
Fault / Trap / Abort
中断处理过程
PC / PSW / 通用寄存器

2 用户态 / 内核态

要会判断：

某条指令在哪个态执行？
什么事件导致态切换？
特权指令有哪些？
trap 为什么能在用户态执行？

3 系统调用

必须会：

参数
→ trap
→ 内核服务
→ 返回

以及：

系统调用 ≠ 库函数
系统调用 ≠ 普通过程调用
模式切换 ≠ 进程切换

七十五、A 级重点

多道程序设计

重点：

为什么产生；
CPU 与 I/O 如何重叠；
CPU 利用率；
吞吐量；
不是进程越多越好。

微内核 vs 宏内核

主要考：

优缺点和位置。

操作系统引导

主要考：

BIOS
→ POST
→ MBR
→ PBR
→ boot loader
→ kernel
→ RAM

七十六、B 级理解即可

操作系统概念；
四个基本特征；
单道批处理；
分时；
实时；
网络 OS；
分布式 OS；
外核；
虚拟机两种类型。

这些并不是不考，而是大多数情况下：

以概念辨析为主。

七十七、第一章最常见的 15 个判断陷阱

建议直接记住下面这些：

内核态只能执行特权指令 错误内核态可以执行全部指令。
用户态可以执行 I/O 指令 错误 I/O 指令通常是特权指令。
trap 是特权指令 错误用户程序需要用它进入内核。
调用库函数一定进入内核态 错误如 sin()、strlen() 可以不进入。
系统调用一定发生进程切换 错误只保证有特权级切换。
中断都是程序错误产生的 错误键盘、网卡、时钟都可以产生外中断。
缺页属于外中断 错误属于异常/Fault。
键盘输入属于异常 错误属于外中断。
多道程序一定需要多核 CPU 错误单核即可并发。
进程数越多 CPU 利用率越高 错误不是单调关系。
分时系统的核心目标是吞吐量最高 错误更强调交互和响应。
实时系统就是运行速度快 错误重点是满足时间约束。
微内核性能通常高于宏内核 错误 IPC 和上下文切换导致额外开销。
BIOS 就是操作系统的一部分 错误 BIOS 是固件，引导 OS。
操作系统最终一直在 ROM 中执行 错误正常运行时内核被加载到 RAM。

七十八、最后把第一章压缩成一张“考场思维图”

                   操作系统
                      │
        ┌─────────────┼─────────────┐
        │             │             │
     管理资源       提供接口       扩充机器
        │             │
 CPU/内存/文件/设备   系统调用
        │
        ↓
并发 + 共享 + 虚拟 + 异步
        │
        ↓
需要保护系统
        │
        ↓
用户态 ←──────────────→ 内核态
        ↑                 ↑
        │                 │
    普通用户程序        OS 内核
        │
        ├──系统调用──────→│
        ├──异常──────────→│
        └──外中断────────→│
                          │
               ┌──────────┼──────────┐
               │          │          │
             调度       内存       I/O
                          │
                     操作系统结构
                          │
              宏内核 / 微内核 / 外核
                          │
                        开机
                          │
 BIOS → POST → MBR → PBR → Bootloader
                          │
                        Kernel
                          │
                         RAM

最值得反复推演的一条链

如果第一章只允许你掌握一套过程，就一定掌握：

用户程序执行
↓
需要 OS 服务
↓
准备系统调用号和参数
↓
执行 trap/syscall
↓
硬件保存关键状态
↓
用户态 → 内核态
↓
内核保存完整现场
↓
查系统调用表
↓
执行服务程序
↓
可能产生 I/O / 阻塞 / 调度
↓
恢复现场
↓
内核态 → 用户态
↓
继续执行用户程序

因为这条链同时串起了：

系统调用、用户态/内核态、特权指令、异常、中断、进程调度、现场保存。

实际上，第 2 章的进程切换、第 3 章的缺页异常、第 5 章的 I/O 中断，都会不断回到这套机制。第一章真正学明白的标志，不是背下定义，而是看到“键盘输入、缺页、read()、时间片耗尽、除零”这些事件时，能立刻判断：谁触发 → 属于中断还是异常 → CPU 处于什么态 → 谁保存现场 → 内核做什么 → 最后返回哪里。

第 1 章 计算机系统概述

第 1 章计算机系统概述