内存碎片整理——停车场的挪车大师

可视化演示

展示内存碎片化可视化、Compaction迁移扫描器协同工作过程、碎片指数仪表与compaction/kswapd双路径协同策略。

碎片类型与成因

观察一座运营三年的露天停车场，你会发现两种让人头疼的浪费。第一种：一辆小轿车大摇大摆地占着两个标准车位，因为管理员只按“标准位”出租，车子只好多占一个——这叫内部浪费。第二种：车位东空一格、西空三格，加起来明明有三十个空位，一支大巴团却因为找不到 12 个连续车位只能走人——这叫外部浪费。这两种浪费，正是内存世界里“内部碎片”与“外部碎片”的翻版。

操作系统把物理内存切成固定大小的页框（通常 4KB），按页分配给进程。进程申请 13KB 内存时，系统分配 4 个页框（16KB），多出的 3KB 再也无法使用，这就是内部碎片。而进程反复加载、退出、扩容后，空闲页框像停车场的空位一样被“稀释”到各处，这就是外部碎片。外部碎片的本质是：空闲内存总量充足，但最大的连续空闲块太小，无法满足高阶分配。

我们可以用一个公式量化碎片化程度：

想象停车场明明还有 30 个空位，最长一排却只有 3 个连位，大巴队就是进不来。内部碎片是“车位太宽、车太瘦”的浪费，外部碎片则是散沙般的空位——它们共同构成了内存长期运行的“慢性病”，而治病的良方，就是后面登场的挪车大师。

伙伴系统与分配瓶颈

停车场管理员老练地定下一套铁规矩：所有区域只按 1、2、4、8、16 这样的“翻倍”方式划分。你要 3 个车位？给你 4 个；要 6 个？给你 8 个。这套翻倍分配法，就是操作系统里的“伙伴系统”（Buddy System）。规则简单高效，也让管理员的账本一目了然。

Linux 内核的伙伴系统把空闲页框按 order（阶数）挂进不同链表：order 0 是 1 个页框，order n 是 \(2^n\) 个连续页框的块。分配 \(2^n\) 页时，若对应链表为空，就向更高阶拆一半下来；释放时，若相邻的“伙伴”块也空闲，则合并回更高阶。这套机制保证了分配速度，却埋下了隐患：长期运行后，大量小块被分配又释放，大块被拆散很难再合并回来，高阶链表逐渐枯竭。

伙伴系统的翻倍划线法简单高效，却挡不住时间的侵蚀。当一个 8 辆连排的大巴位被反复拆成单人位后，管理员再想划一个 16 位大区就难了。好在，他还有第二件法宝——挪车。

内存规整核心机制

大巴队又要来了，管理员决定启动“挪车方案”：把散落在角落的小轿车一辆辆挪到指定区域集中停放，腾出另一端大片连续空位。挪车前先给每辆车贴标签：哪些车能挪（私家车），哪些是不能碰的配电房围挡。这套贴标签、集中挪车的流程，就是 Linux 的内存规整（compaction）机制。

内核将物理内存按 pageblock（通常 128 个页框）划分迁移类型：MIGRATE_MOVABLE 用于用户态可移动页（匿名页、文件缓存），MIGRATE_UNMOVABLE 用于内核代码、页表等不可移动页，MIGRATE_RECLAIMABLE 用于可回收但不宜移动的内核页。执行规整时，内核选好迁移源（可移动页所在的 pageblock）和迁移目标（空闲页所在的 pageblock），逐个把源页内容拷贝到目标页，并改写页表映射和反向映射。页面迁移不只是复制数据，还要更新所有引用它的页表项，成本不低。

挪车方案的精髓在于“分清主次”：焊死的围挡绝不动，能动的车全归拢。迁移成本摆在那里，所以管理员从不轻易出手，而是等碎片指数报警，或者大巴真到门口时才动手。

双扫描器协作

挪车可不是乱搬一气。两位工人从停车场两端出发：A 师傅从东门往西走，专门找贴了“可挪”标签的小轿车；B 师傅从西门往东走，专门找空车位。二人边走边配合——A 找到一辆可挪的车，就把它塞进 B 刚发现的空位。两人越走越近，直到中间碰头，整理结束。

Linux 的 compaction 正是如此。它有两个扫描器：正向扫描器（migration scanner）从区域头部向尾部推进，寻找可迁移页面；反向扫描器（free scanner）从区域尾部向头部推进，寻找空闲页框。每找到一对“源页 + 空闲页”，就把源页迁到空闲位置。两个扫描器各自维护 pfn（页框号）索引：cc->migrate_pfn 和 cc->free_pfn。每轮扫描后把 pfn 缓存在 zone 的 compact_cached_migrate_pfn 里，下次直接从这里继续，避免重复扫描。

两位师傅碰头的那条线，就是停车场新的“秩序线”——一侧是齐整的车阵，另一侧是干净的空地。系统每次扫描都从缓存的 pfn 继续，绝不倒车，把挪车效率拉满。

碎片指数评估

管理员每天上班第一件事，就是看墙上的“停车焦虑指数”仪表盘：指数 0 代表所有空位连成一片，岁月静好；指数 1 代表空位数虽多，但全是碎渣空位，大巴来了只能干瞪眼。这个仪表盘，就是碎片指数（fragmentation index）。

碎片指数衡量的是当前空闲内存中，有多大比例真正能满足分配请求。它由内核在分配路径上动态计算，用来判断此刻执行 compaction 是否值得。计算思路很简单：统计总空闲页数，再统计其中“可组成目标阶数连续块”的页数。若大部分空闲页分散在无法组成大块的位置，指数就接近 1。

碎片指数为系统提供了“动手的底气”：指数高到一定程度，管理员才舍得派挪车小队；指数低时，随便来辆车都能找到位，何必折腾？指数就是一把尺子，量出碎片病到了几分。

规整触发时机

挪车小队不能天天上街——每次折腾都有成本。那什么时候动手？管理员定下两条规矩：一是大巴已经堵在门口，死活找不到连位，只能紧急挪车；二是停车场快满员了，提前派拖车队清理僵尸车，顺手把车位理一遍，防患于未然。

内核同样有两条触发路径。直接规整（direct compaction）：分配进程在 alloc_pages 里寻求高阶连续块失败后，同步执行 compaction，进程阻塞等待整理结果。异步规整：kswapd 发现内存水位紧张时，唤醒后台线程 kcompactd 执行规整，进程不阻塞。直接规整发生在分配请求带 GFP_COMPACT 且 order 大于 0 时，快速路径找块失败后进入慢速路径，调用 __alloc_pages_direct_compact 救火。

紧急挪车和提前整理，一个治标一个治本。内核的分寸感在于：平时让 kcompactd 在后台静静巡检，危机时刻直接规整当场救火，分工明确，绝不浪费。

与 kswapd 协同

如果停车场已经满到连站的地方都没有，光靠挪车就回天乏术了——这时候得请“拖车大队”出场。拖车大队（kswapd）专门把停了好几个月没动的僵尸车拖走，腾出空位；挪车小队（kcompactd）则负责把剩下的车排整齐。两人一前一后，停车场才真正起死回生。

kswapd 是 Linux 内核的页面回收守护线程，当内存水位低于 low 阈值时被唤醒，扫描 LRU 列表回收不活跃页。compaction 与回收有微妙的分工：回收产生的是“可用内存的数量”，而规整解决的是“连续内存的质量”。数量不足时靠回收，连续性不足时靠规整。

在内核的慢速分配路径中，两者协同作战：kswapd 负责把内存压到 low 水位以上，kcompactd 负责把剩余空闲页做成大块。特别地，当无法迁移足够的可移动页面时，内核还会尝试回收不可移动页面之间的可回收页，把“硬骨头”也啃下来。

拖车队和挪车队从不内讧：回收负责“腾数量”，规整负责“造质量”。当停车场终于迎来一辆大巴时，正是这两位师傅的默契配合，才让老旧满员的停车场依然容得下大块头。

AI 应用场景

Python 演示

"""模拟内存碎片化与规整(compaction)过程"""import random class Memory:    def __init__(self, size=64, page_size=4):        self.size = size  # 总页框数        self.pages = [None] * size  # None=空闲, 'mov'=可移动, 'fix'=不可移动        self.page_size = page_size     def alloc(self, cnt, movable=True):        """尝试分配 cnt 个连续页框, 成功返回起始索引"""        typ = 'mov' if movable else 'fix'        for start in range(self.size - cnt + 1):            if all(p is None for p in self.pages[start:start + cnt]):                for i in range(start, start + cnt):                    self.pages[i] = typ                return start        return -1     def free(self, start, cnt):        for i in range(start, start + cnt):            self.pages[i] = None     def max_free_run(self):        best = run = 0        for p in self.pages:            run = run + 1 if p is None else 0            best = max(best, run)        return best     def frag_index(self, need):        """碎片指数: 1 - 能满足 need 的空闲比例"""        free_total = sum(1 for p in self.pages if p is None)        if free_total == 0:            return 0.0        usable = self.max_free_run() >= need        return 1.0 - (need / free_total if usable else 0.0)     def compact(self):        """规整: 将所有可移动页往前搬, 腾出尾部连续区"""        write = 0        for read in range(self.size):            if self.pages[read] == 'mov':                if write != read:                    self.pages[write] = self.pages[read]                    self.pages[read] = None                write += 1 def simulate():    mem = Memory(size=64)    random.seed(42)    for _ in range(30):        cnt = random.randint(1, 8)        start = mem.alloc(cnt)        if start != -1 and random.random() < 0.5:            mem.free(start, cnt)    print("碎片化后: 最大连续块 =", mem.max_free_run())    print("碎片指数 (need=16) =", round(mem.frag_index(16), 2))    mem.compact()    print("规整后: 最大连续块 =", mem.max_free_run())    print("碎片指数 (need=16) =", round(mem.frag_index(16), 2)) if __name__ == "__main__":    simulate()

1. self.pages = [None] * size用数组模拟物理内存页框，None 表示空闲车位，'mov' 和 'fix' 对应可移动与不可移动页面。
2. if all(p is None for p in self.pages[start:start + cnt])检查从 start 开始是否有 cnt 个连续空闲页框，模拟伙伴系统的连续分配约束。
3. return 1.0 - (need / free_total if usable else 0.0)计算碎片指数：最大连续块能满足 need 时按比例折算，否则视为完全碎片化。
4. if self.pages[read] == 'mov': ... write += 1双指针原地规整：把所有可移动页搬到数组前部，腾出尾部连续区，等价于 compaction 的页面迁移。
5. random.seed(42)固定随机种子，保证每次运行结果可复现，方便对比规整前后指标。

常见误区

面试题