页面置换算法全解析：OPT、FIFO、LRU与Clock实战对比

从考研复习到系统编程，存储管理里的“页面置换算法”是绕不开的一环。这篇笔记补的是 OS 内存管理中很关键的一页：当访问页面不在内存、内存又已经满员的时候，操作系统到底该把哪个旧页面请出去，让新的页面进来。页面选得好不好，直接决定程序是流畅跑完还是不断陷入磁盘 IO 的泥潭。这篇内容会围绕 OPT、FIFO、LRU、Clock 以及真实系统中的近似实现展开，适合正在准备操作系统考试、面试，或者想搞明白自己写的服务为什么频繁 swap 的读者参考。

前几篇笔记聊了分段、分页、页表、虚拟内存结构，那是地址转换的“静态地图”；页面置换则是运行时最动态的部分。你写一个程序，不管代码多大，物理内存永远有限，操作系统只能把当前最需要的页留着，其他页先送进磁盘交换区。缺页了，才临时去磁盘捞。说白了，页面置换是一道资源紧张时的“淘汰决策题”，决策质量高不高，缺页率说了算。

1. 先弄清页面置换在存储管理里的位置

1.1 从虚拟存储到缺页中断的基本链路

早期操作系统搞存储管理，经常是“哪段程序还在内存里才能跑”。虚拟存储技术打破了这个限制，进程不需要把所有代码和数据一次性加载进物理内存，只需要保证当前执行到的页面在内存即可。程序看到的是一个连续的巨大虚拟地址空间，实际使用哪一页，由 CPU 访问地址时查询页表来定位。

如果页表项里 Present 标志位为 0，也就是这一页不在物理内存，CPU 会触发缺页异常。缺页异常不是错误，它更像“这块数据不在手边，得去仓库取”的信号。操作系统拿到这个信号后，先检查这块虚拟页是否合法，再从磁盘交换区或缺页设备中把页面读到物理页框。如果当时物理内存有空闲页框，过程很简单：读盘、更新页表、恢复进程执行。麻烦的是内存没有空闲页框，这时候就必须在现有页面里挑一个牺牲者，把它换出去，再把新页面换进来。这个“挑牺牲者”的规则，就是页面置换算法。

把页从内存换到磁盘叫做“换出/淘汰”，把磁盘页面调入内存叫“换入”。页面置换算法研究的就是换出策略。有人觉得硬盘空间够大就行，不是这样的。内存访问是纳秒级别，磁盘乃至 SSD 随机访问通常要几十微秒甚至更高，速度差了两三个数量级。哪怕 1000 次访问里只缺页 1 次，整体性能也会明显下跌。如果在真实服务器上看到内存指标打满后进程响应突然变慢，极可能就是缺页和换页在拖后腿。

1.2 缺页时真正要回答的问题：谁先走

理解页面置换算法其实有一个很简单的锚点：不管算法名字多花哨，它每次缺页时回答的都只是“当前哪个页框被选中淘汰”。

判断一个置换算法好不好，主要看三件事：缺页率是否足够低、单次置换开销是否可控、算法本身能不能在真实硬件上实现。前两者很容易理解，第三个最容易被初学者忽略。比如最优置换算法 OPT 显然缺页率最低，但它要预知未来的访问序列，现实系统不可能知道进程下一秒会访问哪一页，所以只能当作理论标杆。再比如 LRU 在模拟器上表现很好，但要精确记录每个页最近一次访问是几十毫秒前还是几微秒前，硬件支持成本很高。操作系统设计者必须兼顾算法效果和实现成本，这正是 Clock 算法和它的各种改良版能在工业界流行的根本原因。

页面置换的知识结构并不复杂，却很容易让人越学越乱，原因在于算法之间不是简单的谁优谁劣。有些算法是“根据过去预测未来”，有些是“先来先占”，还有些是“参考了访问频率和修改状态组合决策”。把这些算法放一起对比，先看它们各自在干什么，再看为什么现实中往往不用教科书黄金算法，这样才算真正吃透。

1.3 理解局部性原理是前提

前面说的“选谁先走”好像是在猜未来，但计算机科学里有个很强大的经验规律：局部性。一个进程在某段时间内访问的地址空间，往往集中在很小的范围内。循环会反复压同一段指令，数组遍历会连续访问相邻数据，调用栈也总是围绕栈顶附近。正因局部性的存在，页面置换才有规律可循：刚刚被访问的页，很可能在接下来很短时间里又被访问；已经很久没被访问的页，大概率未来一段时间内也不会被访问。

局部性分为空间局部性和时间局部性。页面置换算法主要利用时间局部性。你可能刚开始学时会想，如果算法完全不看访问历史，随便选页行不行？随机淘汰虽然避免了很多麻烦，但不如 LRU 这类利用局部性的算法稳定，因为它没把“哪些页更可能被用到”这个重要信息放进决策。理解局部性之后，再看 FIFO 为什么偶尔表现不如 LRU，就非常清楚：FIFO 只按进入内存的先后排序，完全不关心这个页被访问得有多热。

局部性还是一个度的问题。如果程序的“工作集”本身已经大于可用的物理页框，那么无论页面置换算法多聪明，再多的历史信息也救不了场，最终会走向系统抖动。这个概念后面我会专门讲，它是页面置换算法的边界条件，很多人学到 4.3 节才发现前面算法的前提其实很苛刻。

2. 经典置换算法逐个拆解

2.1 OPT 最优置换：理想标准，无法实现但价值极高

最优置换算法的思想简洁到不像算法：当发生缺页需要淘汰页面时，选择未来最长时间内不再被访问的页面。如果未来永远不会再访问，那就更该它走。

举个例子，内存里目前有页面 A、B、C，接下来 CPU 即将访问的顺序是 A、D、B...，那么把 C 换出去就是最理想的，因为 C 在未来最远才用到。OPT 的缺页率是所有置换算法里理论最低值，因此常被拿来做对照实验的“地板”。你看论文和教材里比较算法，几乎都会引 OPT 作为基准，比如“LRU 的缺页率比 OPT 高 5%”之类。

值得强调的是，OPT 不是实现方案，而是度量工具。你不可能预先知道所有进程的未来访问序列，所以没有任何真实操作系统会直接用 OPT。但它给了两个很重要的启发：第一，页面置换问题理论上存在最优解；第二，算法设计越贴近“未来”，效果越好，而我们能拿到的未来近似信号，只有“过去的访问轨迹”。LRU 和 Clock 能成为经典，本质都是在用过去模拟这个未来。

2.2 FIFO 先进先出：实现最无脑，问题也最明显

FIFO 的实现方式就像给内存页框排了个队列。页面进入内存时排到队尾，发生缺页时直接淘汰队头页面。每个页面都只记录“进入时间”一个维度，谁先来谁先走，不需要额外记录访问情况，硬件软件实现都很简单。

可是 FIFO 有个致命弱点：调用频率和使用时间被混为一谈。一个页面可能是几十毫秒前刚进入的，紧随其后马上就要被访问，但因为它排在队头就可能被淘汰。举个现实中常见的例子：主程序初始化时读入一张配置表，之后每次运行都频繁访问它，紧接着又加载了大量一次性数据块。如果采用 FIFO，内存装满了新数据后，队列会慢慢淘汰最老页面，配置表作为最老的页面也会被换出。于是下一次访问配置表又缺页，系统不得不重新加载，运行效率会明显下降。

FIFO 还有一个更反直觉的现象：分配的物理块数增加，缺页次数反而增加。这就是 Belady 异常。后面第 3 节我会完整推演一次，先记住结论：FIFO 不是“栈式算法”，它不保证驻留集随物理块数单调递增，也就是多给你内存框还可能坏事。你别以为给进程更多内存一定更快，在有页面置换机制时，理论上确实有这种例外。这个案例也是考试和面试最喜欢埋伏笔的地方。

2.3 LRU 最近最久未使用：最符合直觉的经典算法

LRU 的策略一句话就能说清：缺页时淘汰最长时间没有被访问的页面。它的理论依据是时间局部性：如果某页最近被访问过，那在不久的未来它仍可能被访问；如果它已经很久没被访问了，未来短期内大概率也访问不到。

LRU 的模拟过程一般用一个有序列表：每次页面命中，就把这个页提到“最近访问”的那一端；缺页时，从“最久未访问”的那一端拿一个页面换出。这听起来不难，难点在于怎么高效记录和更新访问时间。软件方式可以给每个页表项维护一个计数器或栈，但每次内存访问都要更新计数器或移动栈内节点，开销非常可观。硬件方式可以给每个页框关联一个移位寄存器，每次内存访问时寄存器右移，访问过的页面最高位写 1。判断时看寄存器数值大小，但这样实现需要一整套额外寄存器和比较逻辑，规模一大成本就上去了。

在考试和面试里，LRU 是一个常考常新的对象。它比 FIFO “聪明”，因为它把访问历史和进入先后分开考虑。但请注意，别神化 LRU。如果进程的内存访问局部性非常弱，比如在超大数组上随机跳转访问，LRU 依然会频繁缺页。它只是尽量选择“最可能有用”的页面留下，并不能改变物理内存小于当前活跃工作集的事实。

2.4 Clock 与改进型 Clock：工业界的折中答案

因为纯 LRU 实现成本太高，操作系统研究者想到了近似方案：给每个页框加一个引用位，访问页面时硬件把这个位置 1，定期或置换时清零。当缺页发生时，系统维护一个循环指针，像钟表一样扫过各个页框。如果当前页框引用位是 0，说明这个页面自上次扫描以来没被访问过，那就可以淘汰；如果引用位是 1，系统不淘汰它，而是把引用位清 0，然后继续扫下一个页框。这个算法叫 Clock，也叫二次机会算法。它给每个页面一次“复活”机会：哪怕它是队头，只要最近被访问过，就能多活一轮。扫描一圈后回到原位置，如果所有页面最近都被访问过，那就相当于退化成了 FIFO。可见 Clock 近似地实现了 LRU 的分级。

不过现实情况比引用位更复杂：一个页面被换出需要写磁盘吗？如果页面被修改过，换出时要先写回磁盘，否则数据就丢了；如果页面是干净的，换出时很可能直接丢弃页框内容即可。页表项里的脏位（Dirty bit）记录了页面是否被修改过，因此就有了改进型 Clock 算法，它按引用位 R 和脏位 D 组合把页面分成四个级别：

• (0,0)：既没被访问过，也没被修改过，最佳淘汰候选
• (0,1)：没被访问过但被修改过，淘汰前要写回磁盘，稍次
• (1,0)：被访问过但没被修改过，可能马上用到，再给次机会
• (1,1)：既被访问过又被修改过，最不该淘汰，淘汰代价也最大

改进型 Clock 在做置换时优先扫描第 1 类页面，找不到再依次扩大范围，扫描过程中会把访问位清 0，如果仍找不到需要的级别，会继续下一轮。本质上是在“大概率最近不会再用”和“换出成本低”之间做平衡。它能减少不必要的磁盘写 IO，这也是真实系统非常关心的：内存的换页操作如果总是伴随写盘，整个系统 IO 压力会急剧上升。

2.5 其他相关候选：LFU、MFU、随机与老化

LFU（最不经常使用）统计每个页面被访问的次数，淘汰访问次数最少的页面。听起来很有道理，但存在老问题：曾经高频访问但现在不再使用的页面，会一直赖在内存里，俗称“缓存污染”。相对的 MFU 认为访问次数最多的页面未来最不需要，但这在很多场景下并不成立。所以实际操作中 LFU 需要配合衰减、滑动窗口等机制才能接近理想效果，这也是现代缓存系统里 LFU 的实现远比教材算法复杂的原因。

随机置换算法选一个随机页淘汰，实现简单且不像 FIFO 那样有确定性的反直觉问题，但不可预测的延迟让它也很难被严肃考虑。如果你的程序只有少量页框且页面访问模式完全是随机的，那用任何智能算法都不会比随机好多少；可真实程序几乎都带局部性，所以随机不作为主策略。

老化算法是我比较推荐了解的：它把每个页的使用情况记录在一片二进制位里，定期右移历史位并在最前面插入本次访问位，用整数大小表示“这个页面是否在近期持续被访问”。它比较接近 LRU 的效果，同时避免了维护精确访问时间的成本。很多现代操作系统的页面回收器就是在老化算法基础上扩展出来的，只是名字未必叫老化算法。

3. 动手推演：一套访问序列跑通多个算法

3.1 经典序列的 FIFO 与 LRU 手工计算

学习页面置换算法，光看定义远远不够，必须亲手沿着访问序列一步步推演。这里用操作系统教材里非常经典的一条访问序列来演示，物理块数按 3 个计算。请求序列长度为 20：

7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1

先算 FIFO。整个过程队列始终按“进入内存的先后”排序，命中时队列不动，缺页时淘汰队头。

这个序列在 3 个物理块下，FIFO 出现 15 次缺页。看起来 20 次访问里缺 15 次，等于缺页率 75%，你是不是觉得有点高？这个例子故意设计成访问流浪性很强，也是教材拿来说明算法局限的经典案例，所以不用被这个数字吓到。

再算 LRU。和 FIFO 关键差别在于：命中页面也要把该页放到“最近访问”那一端；缺页时淘汰的是最久未访问的那一页，而不是最早进入页框的页面。我用“驻留集（按最近使用顺序从旧到新）”表示如下：

LRU 算出 12 次缺页，比 FIFO 少了 3 次。其中第 5、7、12、13、15、17、19、20 次访问能命中，都是因为 LRU 更好地保住了最近活跃的页面。也就在这时你能体会到，页面置换算法对系统的影响不只是多一次少一次磁盘访问，而是能直接影响程序的响应延迟。

3.2 OPT 推演与算法对比表

相同序列用 OPT 替换，缺页次数会降到 9 次。前面说过 OPT 每次淘汰“未来最远才访问”的页面。我不在这里把 20 步表格全部贴出来，但可以看一眼关键决策：第 4 步访问 2 时，内存有 7、0、1，未来访问顺序是 0、3、0、4、2……7 在后续序列里要到第 18 步才出现，0 在第 5 步就会出现，1 要到第 14 步，所以淘汰 7 是明智的。后面每一步都以“扫描剩余请求，谁最晚出现淘汰谁”为准则。

不要因为 OPT 最短就以为考试首选它。考试时遇到“给出访问序列，让你算缺页次数”，必须根据题目指定算法来算，通常不会让你实现 OPT，除非明确要求“请计算该序列的 OPT 缺页次数”，那反而要好算很多。

3.3 Belady 异常完整推演：物理块增加，缺页反而变多

Belady 异常是一个非常容易考、也容易做错的知识点。最经典的请求序列是：

1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5

先算 3 个物理块下的 FIFO。前三次缺页装入 1、2、3；访问 4 时淘汰 1；访问 1 时淘汰 2；访问 2 时淘汰 3；访问 5 时淘汰 4；访问 1 时淘汰 5；访问 2 时命中；访问 3 时淘汰 1；访问 4 时淘汰 2；访问 5 时命中。统计缺页次数共 9 次。

再用 4 个物理块跑同样的 FIFO。前四次缺页装入 1、2、3、4，访问 1 和 2 时都命中。随后访问 5，此时队列最老的是 1，于是淘汰 1；下一步访问 1，淘汰队列最老的 2；下一步访问 2，淘汰队列最老的 3；下一步访问 3，淘汰队列最老的 4；下一步访问 4，淘汰队列最老的 5；下一步访问 5，淘汰队列最老的 1。等等，整个过程里 1、2、3、4、5 像一个无限循环被轮换淘汰，最终统计缺页次数为 10 次。怪事出现了：物理块从 3 加到 4，缺页次数反而从 9 升到 10。

FIFO 不是“栈式算法”，意味着它不一定具有栈算法的性质：当物理块增加时，原先驻留的页面集合不一定继续驻留。而 LRU、OPT 这类算法由于某种“按访问历史排序”的单调性，物理块增加时驻留集是单调扩张的，不会出现 Belady 异常。考试问“哪种算法会出现 Belady 异常”，第一反应该是 FIFO，但严格讲，能构造出反例的是不具备栈性质的算法；FRR、随机等也可能构造。

3.4 手工推演时的避坑要点

这个推演过程看起来简单，实际动手写草稿时太容易出错了。我这里记录几个我踩过、也见过很多人踩的坑，你可以直接当成检查清单用。

第一个坑是初始缺页。空内存下第一次访问页面也会缺页，补页也算缺页，很多人从第三次缺页开始数，结果永远差 3 次。正确做法是，刚开始的物理页框为空时，每个首次装入的页面都要计入缺页次数。第二个坑是 FIFO 命中时队列顺序不能变。队列记录的是“进入内存的顺序”，不是“最近使用顺序”。很多人不知不觉把它当 LRU 做了，访问命中后还把页面往前排，统计结果自然不对。第三个坑是 LRU 每次命中必须更新页面的“最近使用”状态。如果不更新，LRU 就会退化成按进入顺序淘汰，等于另一版的 FIFO。

第四个坑是页面编号重复别晕。推演时建议在草稿上画 3 个框，每读一个请求就把框内状态写出来，然后用竖线隔开，不要只在脑子里转。第五个坑是缺页次数统计口径不统一。教材里有的说“缺页次数”包含首次装入，有的考题会说“缺页中断次数”，两者通常一样，但如果你看到“置换次数”就不同了，置换次数不包含首次装入。做题前先把口径看明白，不然算出了结果但被判定错，实在太冤。

4. 真实系统里的页面置换：工程上的折中与避坑

4.1 为什么操作系统不用教材里的纯 LRU

很多人在学完 LRU 以后会问：既然 LRU 效果比 FIFO 好，为什么真实操作系统不直接用 LRU？核心原因有三个：硬件成本、并发风险、语义偏差。

先说硬件成本。精确 LRU 要求每次内存访问都更新每个页面的“最近使用时间”，这在现代 CPU 里几乎做不到。一次内存访问已经够快了，如果还要去更新页框对应的链表节点，硬件布线、比较逻辑、存储开销都会膨胀到无法接受。真做出来，可能性能提升抵不上硬件开销，反而得不偿失。操作系统一般用硬件提供的 Access/Dirty 位低频率收集访问信息，再靠扫描这些位来近似 LRU。

再说并发。现代系统里的进程数远多于物理页框，页面的换入换出由内核页面回收器协调。为每个页面维护精确全局 LRU 顺序，需要一把大锁来保护链表，多核 CPU 并发访问时争抢锁的开销是巨大的。所以真实系统中多采用“多级 LRU 队列”或“分代回收”方式做折中。把活跃页放在一个队列，非活跃页放在另一个队列，回收只在非活跃队列里进行，减少全量扫描的代价。

最后一个因素是语义偏差。LRU 认为“最近用过的页面，未来也更可能用”，但内核里不同页面用途差异巨大：文件缓存页可以干净地回收，进程匿名页必须写回交换区，有些页是内核锁定的或正被 DMA 使用，根本不允许换出。真实回收器必须区分页面类型、文件是否已落盘、是否被进程锁定等，这已经不是单纯 LRU 能覆盖的决策范围。所以工程上采用的页面回收策略更像“优先级 + 引用状态 + 页面类型”组合出来的复杂规则。

4.2 脏页、写回与页面置换的连带关系

页面置换不是简单把页框里的内容丢掉就完事的。如果页面被修改过，换出时要把内容写回磁盘交换区，否则换入时数据就丢了。页表项的 Dirty 位对这一决策影响很大。改进型 Clock 算法把“是否被修改”放进替换优先级，目的就是优先淘汰干净页，因为干净页不需要写回，代价低得多。

在实操层面，系统还会主动做“写回”而不是等到缺页置换才写。内核通常有专门的线程把脏页定期写回磁盘，比如 Linux 的 pdflush 或后来替代它的机制。它能避免缺页时突然被要求执行大量磁盘写操作，降低单次缺页延迟。如果某个进程的驻留集里全是脏页，页面置换发生时系统需要等磁盘写完成才能继续，这种抖动瞬间会让整个进程卡顿很久。

另一个容易忽略的是“页面锁定”。某些内存在执行磁盘 DMA 时不能被换走，因为设备直接访问物理地址，如果页框被回收并分配给别的进程，DMA 会写到人家头上，导致数据灾难。所以页表项里还有锁定位/Pinned 标记，页面回收器遇到这类页会主动跳过。这一块也解释了一个现象：即使系统内存看起来还有空闲，某些进程依然频繁发生缺页或卡顿，可能不是缺内存，而是它的热页面被内核当成缓存页回收了，重新访问就触发读盘。

4.3 抖动与工作集：置换算法救不了的问题

页面置换算法再优秀，也只是在“内存总容量小于活跃需求”时，尽量少付代价。真正的麻烦在于：如果多个进程同时活跃，它们的“工作集”加起来已经大于物理内存总量，那么无论用多聪明的置换算法，系统都会不停地在缺页中断、磁盘读入、写回之间打转，CPU 利用率反而降到很低，这就是抖动（thrashing）。

工作集的定义可以理解为：进程在某段时间窗口内实际访问过的页面集合。只要每个进程当前工作集大小都能放在分配给它的物理内存里，缺页率就会保持在很低的水平。一旦总工作集超过物理内存，页面置换会频繁触发，进程还没干两下活又缺页，系统像停车场满了却还不停有车要进来，闸机一直在开关，车辆却一辆也进不去。

实际系统应对抖动，不会只在置换算法上做文章，而是动态调整每个进程的物理页框数。如果缺页率太高，就给进程多分配一些页框或让它先睡眠，把 CPU 资源让给别的进程；如果缺页率极低，再回收多余的页框给其他进程。考试中经常出现的“工作集模型”“缺页率控制算法”都是为解决抖动问题提出的策略。学习页面置换算法时，如果能记住它只是解决方案的一环，而不是银弹，你会少走很多理解上的弯路。

4.4 备考和项目里真正能用的经验

如果你目前是为了应付考试，我建议你抓住一条主线：每个置换算法本质就是回答“发生缺页时，牺牲者是谁”。做题时不要死记缺页次数，而是把驻留集的状态变化画出来，命中/缺页分开标记。FIFO 看队列，LRU 看访问顺序，改进型 Clock 看 (R, D) 组合，工作集算法看滑动窗口。画图推演比空想更稳。

如果是实际做系统优化，比如你在写缓存、做本地内存池、调 JVM 或数据库参数，那么我对你的建议是先看当前是不是发生了抖动。如果你的程序吞吐量不稳定，系统 swap 占用量高，先别急着换一个置换算法——先考虑能不能减少内存占用、调整缓存大小、增大可分配内存。置换算法的优化通常只能减少缺页带来的二次损失，救不了物理内存严重不足时的系统。真正值得投入的是控制内存里数据的生命期：把冷热数据分开，热数据尽量常驻，冷数据让系统清理。

工作十几年下来，我的感受是页面置换算法是一门“看历史猜未来”的实用决策学。理论上的 OPT 是天花板，FIFO 和 LRU 是教科书里的对照组，而 Clock、老化、工作集这些近似方法才是工程界真正在用的东西。希望你读完这篇笔记后，再去遇到“内存不足、频繁 swap、系统卡顿”这类问题时，能先想到缺页率、脏页写回、工作集这三件事，而不是只抱怨内存太小。能用好这些模型，远比记住缺页次数本身更有价值。