服务跑了一周,内存占用从 200 MB 涨到 1.2 GB,重启就恢复。开发翻代码,没找到明显没释放的地方;运维说“先加内存顶一下”;监控图上 CPU 和请求量都很平稳。三个人面对同一个数字,理解却完全不同:有人看的是进程申请了多少地址空间,有人看的是真正占了多少物理页,还有人看的是分配器手里还留着多少空闲块。
内存这件事,最容易混的就是“地址空间”“已提交”“物理工作集”这几个词。它们不是同一个数。这篇从一个局部变量开始,沿着栈、堆、系统调用走一遍,再看释放之后为什么占用不降,最后把泄漏和碎片分开。
现象:任务管理器里的内存数字,到底是哪一个
任务管理器默认显示的那一列,通常是工作集(Working Set),意思是这个进程当前真正映射在物理内存里的页有多少。它不包括已经申请但还没访问的地址,也不包括被换出到磁盘的部分。另一个常见数字是提交大小(Commit Size),表示系统为这个进程预留了多少可分页的内存额度,哪怕还没真正用上。
所以会出现两种看起来矛盾的现象:提交大小 2 GB,工作集只有 300 MB;或者工作集 1 GB,释放之后只降到 800 MB。前者说明程序预留了很多地址,但没碰;后者说明分配器或运行时把空闲内存留在自己手里,没有还给系统。两个数字都没错,只是回答的问题不同。
还有一个更底层的问题:32 位进程的地址空间只有 4 GB,其中一部分还要留给内核和映射;64 位进程的地址空间大到几乎不用考虑上限,但物理内存仍然是有限的。地址空间够不等于内存够,这是两本账。
场景走查:三种变量,三个位置
写一段最普通的 C 代码,把三类内存放在一起看:
#include <stdio.h>
#include <stdlib.h>
int g_inited = 1; /* 数据段:有初值的全局变量 */
int g_zero; /* BSS:没初值的全局变量 */
int main(void) {
int local = 2; /* 栈:函数内的局部变量 */
int *heap = malloc(sizeof(int)); /* 堆:运行时申请 */
*heap = 3;
printf("global=%p\n", (void*)&g_inited);
printf("bss=%p\n", (void*)&g_zero);
printf("stack=%p\n", (void*)&local);
printf("heap=%p\n", (void*)heap);
free(heap);
return 0;
}
编译运行后,四个地址分属不同区域,具体数值每次都可能变。栈上的 local 随函数调用出现,函数返回就失效;堆上的 heap 要手动释放,不释放就一直占着;两个全局变量从程序启动活到进程结束。它们的生命周期和位置,决定了“谁来回收”这件事。
很多人以为 malloc 直接向操作系统要内存。大多数时候不是。分配器先从自己管理的一大块区域里切一小块给你,只有库存不够时,才向系统要新的页。理解这一层,才能解释为什么释放了内存,进程占用却没怎么降。
栈:函数调用的账本
栈不是“存局部变量的地方”这么简单,它记录的是函数调用的完整现场。每次调用,栈上会压入返回地址、上一层栈帧的指针、保存的寄存器,然后才是局部变量。函数返回时,栈指针回退,这一帧就算没了。局部变量的地址之所以不能返回,就是因为函数一返回,那块栈空间已经不属于你了,后续调用会把它覆盖掉。
栈的大小是有限的。递归太深、局部数组太大,都会把栈撑爆。栈溢出不一定报“内存不足”,常见表现是访问违规、段错误,或者程序直接消失。把大数组放进函数内部,是新手最容易踩的坑之一;改成堆分配,问题立刻消失,但释放责任也跟着来了。
栈的分配和释放几乎是免费的,因为只是移动一个指针。这也是为什么“能放栈上就别放堆上”在性能敏感代码里成立。但它只适合生命周期明确、大小可控的数据。一旦数据要跨函数存活,或者大小在运行时才知道,就得换地方。
栈帧里还有一个容易被忽略的东西:返回地址。函数执行完要跳回调用点,靠的就是它。缓冲区溢出之所以危险,不只是因为写坏了数据,而是因为攻击者可以覆盖返回地址,改变程序执行流。现代系统加了栈保护、不可执行栈和地址随机化,但这些都是提高门槛,不是让越界写入变得无害。写 C 代码时对数组边界保持警惕,仍然是最基本的一条。
堆:malloc 背后的分配器
堆管理器维护着一批空闲块。你调用 malloc(24),它先找一块足够大的空闲区域,切出 24 字节,剩下的继续留在空闲链表里。块头通常还藏着一小段元数据,记录大小和状态,所以实际占用会比你要的多几个字节。
当空闲区域不够时,分配器向系统要更多页。不同平台的接口不一样:Unix 系常用 brk 扩展堆顶,或者用 mmap 直接映射一块;Windows 用虚拟内存接口预留再提交。大块分配常常绕过小块堆,直接映射独立的页区,释放时也直接还给系统。
这就解释了两种不同的“释放后不降”。第一种是分配器把空闲块留在自己的池子里,打算下次复用,因为向系统要页比复用慢得多;第二种是空闲块太碎,虽然总量够,但没有一块连续的能满足新请求,分配器只能继续要新页。前者是策略,后者是碎片。
分配器还要处理对齐。多数平台要求数据从 4、8 或 16 字节边界开始,分配器会把请求大小向上取整,再切块。所以一个 5 字节的请求,实际占用的可能是 16 字节甚至更多。大量小对象会把这份取整成本放大,也是为什么高频分配的场景会用对象池,而不是一次次调用通用分配器。
多线程程序里,分配器通常为每条线程准备独立的缓存区域,减少锁竞争。代价是内存会在各线程的缓存里分散着,释放之后不一定回到全局池,更不一定回到系统。这也是“同样一段逻辑,单线程跑内存很正常,多线程跑占用偏高”的一个常见来源。
实测:大块和小块,释放后工作集怎么变
写一个 Windows 小程序,用系统接口读取当前进程的工作集,分别在分配前后、释放前后打印。先看大块分配:一次要 200 MB,按页触碰,再整体释放。
#include <windows.h>
#include <psapi.h>
static void show(const char *label) {
PROCESS_MEMORY_COUNTERS pmc;
if (GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc))) {
printf("%s working_set=%zu KB\n", label, (size_t)(pmc.WorkingSetSize / 1024));
}
}
/* main 中:show("start"); 分配 200MB 并逐页写入; show("after touch"); free; show("after free"); */
本机 gcc 16.2 编译运行,实际输出:
start working_set=4984 KB
after touch working_set=211492 KB
after free working_set=6692 KB
大块释放后,工作集从 211 MB 掉回 6.7 MB,基本还给了系统。再看小块:分配 20 万个 1 KB 的块,逐个写入,再逐个释放。
start working_set=4980 KB
after 200k x 1KB working_set=212552 KB
after free working_set=7224 KB
在这台 Windows 机器上,小块释放后工作集也降回去了。这个结果不能直接推广到所有平台:Linux 的 glibc 分配器对小块的归还策略更保守,释放后仍然保留在进程的 arena 里,工作集可能维持高位。具体行为取决于分配器版本和分配模式,未在本机实测,不能拿一个平台的输出当通例。
这段实验真正要说明的是:你看到的“进程占用”是分配器和操作系统共同作用的结果,不是 free 一行代码的直接映射。要判断有没有泄漏,得看长期趋势和分配点,而不是看某一刻的数字。
内存泄漏和内存碎片,不是一回事
泄漏是“程序再也找不到那块内存了”。指针被覆盖、容器只增不减、异常路径跳过释放,都会造成泄漏。它的特征是占用随时间单调上涨,重启后归零,分配器手里的空闲块并没有变多。
碎片是“内存还在,但用不上”。总空闲量足够,却被切成了很多不连续的小块,来一个较大的请求就满足不了。它的特征是进程占用很高,但分配大块时仍然失败,或者性能逐渐下降。碎片不一定是泄漏,释放逻辑可能完全正确。
还有一种介于两者之间的状态:分配器缓存。内存既没泄漏,也没碎片,只是分配器留着备用。它会在内存压力下归还,或者达到阈值后归还。看到占用高就断定泄漏,容易把这类正常行为当成 bug。
举个真实常见的例子:一个进程里有一张只增不删的映射表,每次请求往里面塞一个结果,用来做“临时缓存”。代码逻辑没有错,引用也都能找到,所以它不是传统意义上的泄漏;但从内存角度看,它和泄漏没有区别,因为这张表永远不会缩小。排查时不能只搜 free 和 delete,还要找那些“只增不减”的容器。
反过来,碎片问题往往出现在长时间运行、块大小混杂的服务里。日志缓冲区、连接对象、临时字符串大小不一,释放顺序又乱,空闲区域被切得七零八落。这时候总空闲量看起来很大,但申请一个稍大的连续块就失败。解决办法不是简单加内存,而是统一尺寸、使用池化,或者把大对象单独走一条分配路径。
现象对照表
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 进程占用随时间一直涨,重启归零 | 典型泄漏:某条路径分配后没有释放 | 按分配点做统计,看哪类对象数量只增不减 |
| 释放后占用只降一点 | 分配器保留空闲块,或大块走了不同的映射路径 | 区分工作集和提交大小,观察长时间趋势而不是瞬时值 |
| 总空闲内存够,分配大块却失败 | 地址空间碎片,缺少连续区域 | 看分配失败时的请求大小和地址空间布局 |
| 函数返回局部数组后数据乱掉 | 返回了栈上的地址,函数返回后栈帧失效 | 检查返回类型是否指向局部变量,改成堆分配或由调用方传入 |
| 递归深一点就崩溃 | 栈空间耗尽,栈溢出 | 看崩溃地址是否贴近栈边界,减少递归深度或改迭代 |
| 程序刚启动就占了几百 MB | 地址空间预留、运行时初始化、依赖库映射 | 对比提交大小和工作集,确认是预留还是真用了 |
| 32 位程序总在大内存分配上失败 | 地址空间上限只有 4 GB,且被系统和映射占用 | 看进程位数和地址空间布局,考虑改 64 位 |
| 容器里内存超限被杀 | 容器统计的是工作集或用量,不是宿主机的空闲内存 | 看容器内存指标和限制值,确认是否有缓存未归还 |
边界与代价
栈快,但容量小、生命周期短;堆灵活,但分配释放有成本,还要自己管生命周期。垃圾回收语言把释放自动化了,代价是运行时开销和不可控的停顿;手动管理语言把控制权交给你,代价是泄漏、悬垂指针和重复释放。没有哪种方式全面占优,只有适不适合当前场景。
另一个代价是观测本身。不同工具报告的口径不一样:有的算工作集,有的算私有字节,有的算分配器统计的堆用量。排查时先把口径统一,再比较趋势,否则很容易得出“内存泄漏”的结论,实际上只是换了统计方式。
还有一点要记住:操作系统不会因为一个进程申请了地址空间就给它物理页。真正占内存是在第一次写入时发生的,这叫按需分配。所以“预留 1 GB”不等于“用了 1 GB”,而“碰了 1 GB”之后即使释放,系统也可能因为缓存和分配器策略,不立刻把数字降下来。
不少系统允许超额分配(overcommit):进程申请的总额可以超过物理内存加交换空间,真正紧张时再靠淘汰或杀掉进程来兜底。好处是程序不用为“可能用到”的内存提前买单,坏处是内存压力来的时候,报错不在申请点,而是在某次写入时突然被系统终止。部署时要确认系统的超额分配策略,别把“申请成功”当成“内存已经安全”。
这也意味着,容量规划不能只看“峰值申请了多少”,还要看峰值时真正驻留了多少、交换空间够不够、系统会不会在压力下杀进程。申请额度、驻留页和可回收缓存是三本账,缺一本都算不清。
当天能自己验证的练习
- 把上面的 C 程序编译运行,打印四类地址,确认栈、堆、数据段的位置关系;连续运行两次,观察地址是否变化。
- 把 200 MB 分配改成 200 个 1 MB 的块,释放一半,观察工作集变化,再全部释放,对比两次结果。
- 写一个函数返回局部数组的地址,在调用方打印内容,观察数据被覆盖的现象;再改成由调用方传入缓冲区。
- 用递归计算一个较大的斐波那契数,逐步加大深度,观察栈溢出时的表现;再改成迭代版本对比。
- 在 Linux 上用
valgrind --leak-check=full跑一个故意泄漏的小程序,看它如何定位分配点。本机没有 Linux 环境,这一条未在本机实测。
小结与下一篇
内存不是一块,而是几块:栈存调用现场和局部变量,堆存运行时申请的数据,数据段和 BSS 存全局变量,映射区装共享库和大块映射。malloc 先找分配器的空闲块,不够才向系统要页;释放后是否归还,取决于分配器策略和块的形态。泄漏是找不到的内存,碎片是找得到却用不上的内存,两者要分开排查。
排查时先问三个问题:数字是哪个口径,趋势是上涨还是波动,分配点在哪里。把这三件事答清楚,比盯着一个瞬时值猜要靠谱得多。口径统一了,再谈优化,否则优化对象可能根本不存在。
下一篇讲8G 内存跑 16G 程序:虚拟内存与页表。上面反复提到“预留”和“提交”,但还没回答一个更根本的问题:为什么每个进程都以为自己独占一整块地址空间,物理内存又是怎么被悄悄复用的。这就要看虚拟内存和页表。