操作系统中的基于计数页面置换算法

引言：当经典算法遇上 2026

当我们回顾操作系统的发展历程，页面置换算法始终是内存管理的核心。在 2026 年的今天，尽管硬件性能突飞猛进，但理解基于计数的算法（如 LFU 和 MFU）对于构建高性能、云原生的应用依然至关重要。在这篇文章中，我们将不仅重温经典，还会结合当下最前沿的“氛围编程”和 AI 辅助开发理念，探讨如何用现代化的视角审视这些算法。

基于计数的页面置换算法的核心逻辑非常直观：我们根据页面过去被访问的次数来决定它的命运。如果超过一个页面具有相同的计数值，那么通常采用 FIFO（先进先出）策略，替换最先占据该帧的页面。

页面置换（Page Replacement）：这是一种当主存的所有帧都被占用，且 CPU 请求的数据不在主存中时，用辅存的数据块（页面）来替换主存数据块（帧）的技术。从技术上讲，这就是当发生缺页中断时发生的事情。

两种基于计数的算法

• 最不常用（LFU）算法：它替换掉计数比其他页面少的页面，也就是过去访问次数最少的页面。
• 最常用（MFU）算法：它替换掉计数比其他页面多的页面，也就是过去访问次数最多的页面。

示例

假设我们有一个主存，帧数 = 4，以下是 CPU 提出的数据块访问请求。

> ### CPU 请求序列 – 7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 7, 3, 2, 1

已知，帧数 = 4。最初，所有帧都是空的。

使用最不常用（LFU）算法

(i) 最初 4 个帧是空的，前 4 个数据块占据了它们。

> ### 7 , 0 , 1 , 2 , 0, 3, 0, 4, 2, 3, 7, 3, 2, 1

!Step 1

(ii) 数据块 0 已经占据了帧。

> ### 7 , 0 , 1 , 2 , 0 , 3, 0, 4, 2, 3, 7, 3, 2, 1

!Step 2

(iii) 数据块 2、1、7 被访问的次数最少（各一次），且数据块 7 最先占据了帧，因此，数据块 7 被进入的数据块 3 替换。

> ### 7 , 0 , 1 , 2 , 0 , 3 , 0, 4, 2, 3, 7, 3, 2, 1

!Step 3数据块 7 被数据块 3 替换

(iv) 数据块 3、0 已经占据了帧。

> ### 7 , 0 , 1 , 2 , 0 , 3 , 0 , 4, 2, 3, 7, 3, 2, 1

!Step 4

(v) 数据块 2、1、3 被访问的次数最少（各一次），且数据块 1 最先占据了帧，因此，数据块 1 被进入的数据块 4 替换。

> ### 7 , 0 , 1 , 2 , 0 , 3 , 0 , 4 , 2, 3, 7, 3, 2, 1

!Step 5数据块 1 被数据块 4 替换

(vi) 数据块 2、3 已经占据了帧。

> ### 7 , 0 , 1 , 2 , 0 , 3 , 0 , 4 , 2 , 3 , 7, 3, 2, 1

!Step 6

(vii) 数据块 4 被访问的次数最少（一次），因此被进入的数据块 7 替换。

> ### 7 , 0 , 1 , 2 , 0 , 3 , 0 , 4 , 2 , 3 , 7 , 3, 2, 1

!Step 7数据块 4 被数据块 7 替换

(viii) 数据块 3、2 已经占据了帧。

> ### 7 , 0 , 1 , 2 , 0 , 3 , 0 , 4 , 2 , 3 , 7 , 3 , 2 , 1

!Step 8

(ix) 数据块 7 被访问的次数最少（两次），因此被进入的数据块 1 替换。

> ### 7 , 0 , 1 , 2 , 0 , 3 , 0 , 4 , 2 , 3 , 7 , 3 , 2 , 1

!Step 9数据块 7 被数据块 1 替换

> 缺页次数 = 不存在于主存中并被调入主存的数据块数量

#### 上述示例中的缺页次数 = 8

#### 请参考:- 使用最常用（MFU）算法的示例 以了解 MFU 算法是如何工作的。

比较 MFU 和 LFU 基于计数的算法

最不常用 (LFU)

—

替换访问次数最少的页面。

由于最不常用的页面被替换，这会减少缺页次数，因为该页面在未来被再次访问的几率较低。## 2026 深度解析：现代开发范式下的算法实现

让我们把目光转向 2026 年。现在的开发环境已经大不相同，我们在编写底层算法时，不仅要考虑算法本身的时间复杂度，还要考虑代码的可维护性、AI 辅助开发的友好度以及云原生环境下的表现。

LFU 算法的现代实现与代码剖析

在我们的最新项目中，我们需要为一个高性能缓存系统实现 LFU。简单的计数器可能会导致“缓存污染”，即某个页面偶尔被访问多次后就长期占据内存。为了解决这个问题，我们通常会结合时间衰减机制。

让我们来看一个经过优化的 LFU 实现思路。我们将使用 Python 风格的伪代码来展示，这更符合我们在使用 Cursor 或 GitHub Copilot 进行“氛围编程”时的习惯——代码即文档，逻辑清晰自然。

import heapq
from collections import defaultdict

class LFUCache:
    """
    一个结合了频率和访问时间的现代 LFU 缓存实现。
    我们使用最小堆来维护频率，同时记录时间戳以处理平局。
    """
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.min_freq = 0
        # key -> value
        self.val_map = {}
        # key -> frequency
        self.freq_map = {}
        # frequency -> set of keys (为了 O(1) 获取同频率的 key)
        self.freq_keys_map = defaultdict(set)
        
    def get(self, key: int) -> int:
        if key not in self.val_map:
            return -1
        
        # 获取当前频率并增加
        freq = self.freq_map[key]
        self.freq_map[key] = freq + 1
        
        # 从旧的频率集合中移除，加入新的频率集合
        self.freq_keys_map[freq].remove(key)
        self.freq_keys_map[freq + 1].add(key)
        
        # 如果旧的频率集合为空且是最小频率，更新最小频率
        if not self.freq_keys_map[freq] and self.min_freq == freq:
            self.min_freq += 1
            
        return self.val_map[key]

    def put(self, key: int, value: int) -> None:
        if self.capacity = self.capacity:
            # 从最小频率集合中弹出一个 Key
            evict_key = self.freq_keys_map[self.min_freq].pop()
            del self.val_map[evict_key]
            del self.freq_map[evict_key]
            
        # 添加新元素
        self.val_map[key] = value
        self.freq_map[key] = 1
        self.freq_keys_map[1].add(key)
        self.min_freq = 1

这段代码展示了我们如何在 2026 年编写代码：不仅要实现功能，还要处理好边界情况，并且通过详细的文档字符串让 AI 能够更好地理解我们的意图。

常见陷阱与调试技巧

在我们最近的一次代码审查中，我们发现了一个 LFU 实现中的微妙 Bug。当并发访问增加时，简单的计数器可能会因为竞态条件而导致计数不准确。虽然在单线程 OS 演示中没问题，但在现代多核服务器环境下，这是致命的。

我们是如何发现的？

我们利用了 LLM 驱动的调试技术。通过将并发日志输出给 AI 模型，AI 迅速识别出了 min_freq 更新逻辑中的不一致性。这告诉我们，传统的 Debug 方法正在被 AI 辅助分析所取代。

解决方案：

在生产环境中，我们建议使用原子操作或锁来保护频率计数器，或者采用更无锁的数据结构。在 Go 或 Rust 等现代语言中，利用 channel 或 ownership 机制可以更安全地处理这些问题。

边缘计算与云原生场景下的应用

2026 年是边缘计算大爆发的一年。在边缘设备上，内存资源极其宝贵。基于计数的算法在这里找到了新的用武之地。

动态调整策略

在我们的边缘节点服务中，传统的 LFU 可能不够灵活。我们引入了 Agentic AI（自主 AI 代理） 来监控内存命中率。AI 代理会根据当前的访问模式，动态调整页面置换的权重。

例如，如果 AI 发现某个时间段内突发性流量导致 LFU 频繁置换热点数据，它可以临时将策略切换为类似 LRU 的模式，或者直接提升某些热点页面的优先级，使其不被置换。这就是所谓的“可观测性驱动进化”。

实际决策经验

什么时候不使用 LFU？

• 存在周期性访问模式时：如果你的应用每隔一小时就会访问一次特定的数据集，LFU 可能会因为之前积累的高频计数而保留了过时的热点数据。这时，LRU 或简单的 FIFO 反而效果更好。
• 一次性扫描大量数据时：这被称为“一次性扫描攻击”。如果你的数据集被全量扫描一次，LFU 会导致之前的缓存被彻底清空。我们通常通过设置“老化时间”来解决这个问题，即定期将所有计数减半。

总结

从教科书的示例到 2026 年的云端实践，基于计数的页面置换算法依然有其生命力。我们不仅需要理解其基本原理，更要学会结合现代开发工具——无论是使用 AI IDE 进行结对编程，还是利用多模态监控来优化系统性能。

希望这篇文章能帮助你更好地理解 LFU 和 MFU 算法，并在你的下一个技术选型中做出明智的决定。