一个后台服务上线时 RSS 是 200MB,跑一周涨到 2GB,重启立刻回到 200MB。CPU 正常,QPS 正常,日志里没有 OOM,也没有崩溃。运维问是不是内存泄漏,开发第一反应是「代码里没有 new」。
另一个服务更安静:两个模块互相注册回调,都拿 shared_ptr 持有对方。打印 use_count 一直是 2,析构函数从来没执行过。服务不崩,内存每天涨一点,直到某次发布重启才「恢复」。
这篇讲清这两件事:对象住在栈、堆还是静态区;为什么默认用 unique_ptr;make_unique 和 make_shared 省了什么;shared_ptr 的计数为什么停在 2;自定义删除器怎么写;裸 new/delete 还剩哪些必要场景;以及智能指针也解决不了的悬垂引用。
现象:只涨不降,和「不析构」
先分清三种「涨」。真泄漏的特征是 RSS 随请求单调上涨、重启归零、压测停止后也不明显下降;缓存的特征是涨到某个水位后平稳,重启后重新爬升;内存碎片的特征是小块分配很多、RSS 高但堆里没有对应的大对象。三者处理方式完全不同,先分类再动手。
循环引用的特征更具体:该析构的对象没析构。在所有析构函数里打一行日志,正常退出时应该能看到每个对象收尾;如果一条都没有,先怀疑所有权成环,而不是去查 new 和 delete 有没有配对。
排查顺序永远是先量再猜:RSS、容器 size()、对象计数、分配次数。没有度量就改代码,等于闭眼修车。
栈、堆、静态存储:对象到底住在哪
写个小程序把析构时机打出来:
#include <iostream>
struct Probe {
const char* n;
explicit Probe(const char* name) : n(name) { std::cout << "ctor " << n << "\n"; }
~Probe() { std::cout << "dtor " << n << "\n"; }
};
Probe g{"global"};
void f() {
Probe local{"local"};
std::cout << "in f\n";
}
int main() {
f();
std::cout << "back in main\n";
}
本机输出:
ctor global
ctor local
in f
dtor local
back in main
dtor global
global 在 main 之前构造,local 在 f 返回时析构,global 在 main 返回之后才析构。栈对象的释放几乎只是移动栈指针;堆分配要找分配器、维护元数据,慢得多。这也是为什么「能在栈上就别放堆上」是一条实用原则。
两个直接后果:递归太深、局部数组太大,会栈溢出;全局或函数内 static 的容器只往里塞、从不清理,看起来像泄漏,其实是逻辑上没有上限。栈对象的地址出了作用域就作废,所以不能返回指向局部变量的指针或引用;堆对象不会自己消失,所以必须有一个明确的 owner。
为什么默认用 unique_ptr
理由三条:所有权唯一,读代码就知道谁负责释放;默认删除器下没有额外开销,本机 x64 实测 sizeof(unique_ptr<int>) 是 8,和裸指针一样;不可拷贝、只能移动,编译期就挡住「两个 owner」的错误。
auto p = std::make_unique<Conn>("db");
auto q = std::move(p); // p 变成 nullptr
// auto r = q; // 编译错误:unique_ptr 不能拷贝
接口设计上,转移所有权用 unique_ptr<T> 按值或按右值引用传参,只观察用 const T& 或 T*,不要传 unique_ptr<T>&,除非函数真的要换掉它。get() 只借出裸指针,release() 放弃所有权(必须有人接住,否则泄漏),reset() 换对象或清空。
unique_ptr 表达的是「同一时刻只有一个 owner」。需要共享所有权时它不适用,这时才轮到 shared_ptr;不要因为「省事」直接上共享,共享的代价在后面几节会看到。
unique_ptr:独占
一个对象一个 owner,析构时机确定,没有控制块和原子计数,本机实测大小和裸指针一样。适合绝大多数资源句柄。
shared_ptr:共享
多个 owner 共同持有,最后一个释放时销毁。代价是控制块、原子计数,以及可能出现的循环引用,只在确实说不清生命周期时用。
完整走查:一个连接管理器
需求:创建连接、交给使用方、用完自动关闭,批量清理时一次释放。所有权全程只有一个,正好用 unique_ptr。
#include <iostream>
#include <memory>
#include <string>
#include <utility>
#include <vector>
class Conn {
public:
explicit Conn(std::string name) : name_(std::move(name)) {
std::cout << "open " << name_ << "\n";
}
~Conn() { std::cout << "close " << name_ << "\n"; }
Conn(const Conn&) = delete;
Conn& operator=(const Conn&) = delete;
const std::string& name() const { return name_; }
private:
std::string name_;
};
std::unique_ptr<Conn> makeConn(const std::string& n) {
return std::make_unique<Conn>(n);
}
void use(std::unique_ptr<Conn> c) {
std::cout << "use " << c->name() << "\n";
}
int main() {
auto a = makeConn("db");
std::cout << "before move, a null? " << (a == nullptr) << "\n";
use(std::move(a));
std::cout << "after move, a null? " << (a == nullptr) << "\n";
std::vector<std::unique_ptr<Conn>> pool;
pool.push_back(makeConn("cache"));
pool.push_back(makeConn("queue"));
std::cout << "pool size=" << pool.size() << "\n";
pool.clear();
std::cout << "after clear, pool size=" << pool.size() << "\n";
}
编译运行(本机实测):
g++ -std=c++20 -Wall -Wextra unique_demo.cpp -o unique_demo.exe
.\unique_demo.exe
open db
before move, a null? 0
use db
close db
after move, a null? 1
open cache
open queue
pool size=2
close cache
close queue
after clear, pool size=0
逐段看:db 在 use() 返回时关闭,因为参数按值收走了所有权;move 之后 a 变成空,再解引用就是空指针;pool.clear() 依次销毁两个连接。本机看到 cache 先于 queue 析构,但 vector 的销毁顺序是实现细节,别写代码依赖它,需要顺序就显式遍历 reset()。
这段代码里没有一处手写 delete,异常路径也不漏:use() 中途抛异常,参数 c 照样会析构。
make_unique 和 make_shared 到底省了什么
make_unique 不只是少写一个 new。看这个调用:f(std::unique_ptr<T>(new T), g())。两个实参的求值顺序不确定,如果 g() 先执行并抛异常,new 出来的 T 还没有 owner,直接泄漏。换成 f(std::make_unique<T>(), g()),临时 unique_ptr 先构造好,后面抛异常也能析构。这就是「异常安全」在这里的具体含义。
make_shared 把对象和控制块(强计数、弱计数)放在一次分配里:少一次分配,对象和计数相邻,缓存更友好。代价有两个:只要还有 weak_ptr 活着,整块内存(包括对象本身)都不释放;make_shared 不能带自定义删除器。
shared_ptr 本身是两个指针大小,本机实测 16;每次拷贝都要原子加一。函数参数用 const shared_ptr<T>& 能避免计数抖动,但更该先问:这里真的需要共享所有权吗?能 unique_ptr 就别 shared_ptr。
shared_ptr 的计数,和循环引用
shared_ptr 的计数表示「有多少个 shared_ptr 指向这个对象」,归零才析构。两个对象互相指,计数就永远不会归零。
#include <iostream>
#include <memory>
#include <string>
struct Node {
std::string name;
std::shared_ptr<Node> next;
~Node() { std::cout << "~Node " << name << "\n"; }
};
int main() {
auto a = std::make_shared<Node>();
a->name = "a";
auto b = std::make_shared<Node>();
b->name = "b";
a->next = b;
b->next = a;
std::cout << "cycle: a refs=" << a.use_count()
<< " b refs=" << b.use_count() << "\n";
a.reset();
std::cout << "after a.reset: b refs=" << b.use_count() << "\n";
std::cout << "end of main\n";
}
本机输出:
cycle: a refs=2 b refs=2
after a.reset: b refs=2
end of main
注意最后没有任何 ~Node 输出:两个对象都还活着,只是外部已经拿不到它们了。a.reset() 只放掉了外部那一个计数,a 仍被 b->next 持有,b 仍被 a->next 持有,于是整组对象不可达但计数非零。
真实代码里这种结构很常见:父对象 shared_ptr 持有子对象,子对象又 shared_ptr 指回父;session 持有 connection,connection 的回调又捕获 session;对象把自己的 shared_ptr 存进自己的成员或自己的回调里。写的时候每一处都「合理」,连起来就成了环。
另外要分清:shared_ptr 的计数是原子的,多个线程拷贝、销毁同一个 shared_ptr 对象是安全的;但它指向的对象不是线程安全的,两个线程同时改同一个 shared_ptr 变量也要加锁。
weak_ptr:打破循环,也用来观察
weak_ptr 只观察、不拥有:不增加强计数,不能直接解引用,用 lock() 拿一个临时的 shared_ptr,对象已死就返回空。把上面 next 改成 weak_ptr,环就断了。
#include <iostream>
#include <memory>
#include <string>
struct WNode {
std::string name;
std::shared_ptr<WNode> next;
std::weak_ptr<WNode> prev;
~WNode() { std::cout << "~WNode " << name << "\n"; }
};
void build() {
auto a = std::make_shared<WNode>();
a->name = "a";
auto b = std::make_shared<WNode>();
b->name = "b";
a->next = b;
b->prev = a;
std::cout << "weak: a refs=" << a.use_count()
<< " b refs=" << b.use_count() << "\n";
auto back = b->prev.lock();
std::cout << "lock from b: ok=" << (back != nullptr) << "\n";
a.reset();
std::cout << "after a.reset: b->prev expired=" << b->prev.expired() << "\n";
}
int main() {
build();
std::cout << "returned from build\n";
}
本机输出:
weak: a refs=1 b refs=2
lock from b: ok=1
after a.reset: b->prev expired=0
~WNode a
~WNode b
returned from build
a refs=1,因为只有局部变量 a 持有它,b->prev 是 weak 不算;b refs=2,是局部 b 加 a->next。关键在第三行:lock() 出来的 back 还活着,它让 a 的计数变成 2,所以 a.reset() 后 expired() 仍然是 0——对象没死,因为 back 还持有它。离开 build 时先析构 a,a 释放 next,再析构 b。
这段输出正好说明 lock() 的语义:拿到 shared_ptr 就保活,检查完要尽快让它离开作用域。weak 的典型用途:打破循环、做缓存(weak 观察,真正的 owner 在别处)、维护观察者列表。
自定义删除器
不是所有资源都能 delete。文件句柄要 fclose,C 内存要 free,第三方库有它自己的 destroy。这些都能交给 unique_ptr 的第二个模板参数。
#include <cstdio>
#include <iostream>
#include <memory>
int main() {
auto closer = [](FILE* f) {
if (f) {
std::fclose(f);
std::cout << "fclose called\n";
}
};
{
std::unique_ptr<FILE, decltype(closer)> fp(std::fopen("tmp.txt", "w"), closer);
if (fp) std::fputs("hello", fp.get());
}
std::cout << "sizeof(default unique_ptr<int>) = "
<< sizeof(std::unique_ptr<int>) << "\n";
std::cout << "sizeof(lambda deleter) = "
<< sizeof(std::unique_ptr<FILE, decltype(closer)>) << "\n";
std::cout << "sizeof(function-pointer deleter) = "
<< sizeof(std::unique_ptr<FILE, int (*)(FILE*)>) << "\n";
std::remove("tmp.txt");
}
本机输出:
fclose called
sizeof(default unique_ptr<int>) = 8
sizeof(lambda deleter) = 8
sizeof(function-pointer deleter) = 16
无捕获的 lambda 是空类型,能被空基类优化吃掉,所以还是 8 字节;函数指针要存一个地址,变成 16 字节;有捕获的 lambda 会把捕获的变量存进去,类型更大,还可能因此不能拷贝。删除器只在指针非空时调用,fclose 的返回值会被忽略。删除器本身不能抛异常。
代价是类型变了:unique_ptr<FILE, decltype(&fclose)> 和 unique_ptr<FILE> 不是同一种类型,跨接口传递要统一删除器类型,否则编译不过。
什么时候裸 new/delete 仍然必要
业务代码里基本不该出现 delete,但有几处绕不开:
- 对接 C API。库返回
FILE*、malloc的内存,或要求用xxx_destroy释放的句柄。做法不是手写delete,而是立刻包进unique_ptr加删除器,让它的生命周期跟着作用域走。 - placement new。在已经分配好的内存上构造对象,常见于内存池、固定缓冲区、容器和分配器底层。必须显式调用析构,不能用
delete。 - 第三方 API 规定生命周期。对象必须由它创建和销毁,只能按它的规则来,外面包一层 RAII 管理句柄。
- 自己实现容器或分配器。这类底层代码需要直接操作内存,属于少数派。
#include <iostream>
#include <memory>
#include <new>
struct Item {
int id;
explicit Item(int i) : id(i) { std::cout << "ctor " << id << "\n"; }
~Item() { std::cout << "dtor " << id << "\n"; }
};
int main() {
alignas(Item) unsigned char buf[sizeof(Item)];
Item* p = new (buf) Item(7);
std::cout << "id=" << p->id << "\n";
p->~Item();
std::cout << "sizeof shared_ptr<int>=" << sizeof(std::shared_ptr<int>) << "\n";
std::cout << "sizeof unique_ptr<int>=" << sizeof(std::unique_ptr<int>) << "\n";
}
本机输出:
ctor 7
id=7
dtor 7
sizeof shared_ptr<int>=16
sizeof unique_ptr<int>=8
buf 是栈上的字节数组,new (buf) Item(7) 只调构造函数,不分配内存;p->~Item() 手动收尾。placement new 的正确配对是「构造 + 显式析构」,把这个栈地址交给 delete 是未定义行为,通常会以无效释放的错误结束。
结论:new 表达式还会出现,但 delete 应该被包装起来。真正需要手写 delete 的地方极少,遇到时先想想是不是漏了某个现成的删除器。
智能指针解决不了的:悬垂引用
智能指针管的是「什么时候释放」,不管「你手里的引用还能不能用」。
#include <iostream>
#include <string>
#include <vector>
int main() {
std::vector<std::string> names{"alice", "bob"};
const std::string& first = names[0];
for (int i = 0; i < 100; ++i)
names.push_back("extra-name-" + std::to_string(i));
std::cout << "first=" << first << "\n";
}
本机输出就是一行 first=,后面什么都没有。原因是 names 扩容时元素被搬走,first 还指着旧地址;旧内存已经释放,读出来是空串。这是 UB,可能空、可能乱码、也可能崩,本机这次只是「安静地错」。
同类问题还有:lambda 捕获局部变量的引用后被异步执行;类成员存 const T& 指向别人的临时对象;异步回调捕获 this,对象先死;shared_ptr 的引用成员在 owner reset() 之后悬垂。
解法:要保存就存值(拷贝 std::string 或对象)或存 weak_ptr 并在使用时 lock();引用和裸指针只在不跨越生命周期的地方用;异步任务用值捕获或 shared_ptr 捕获;容器里存下标可以避开扩容,但删除元素后下标同样可能失效。
现象、真实原因、第一步查什么
内存问题最难的是「没有现场」。下面这张表按现象分流,工具输出里的示例来自常见格式,本机没有 valgrind 和 ASan,未实测。
| 你看到的现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| RSS 随请求单调上涨,重启归零,压测停了也不降 | 真泄漏:分配后没释放,或容器只增不删 | 先看增长与请求量是否相关;在构造/析构里加计数,对比请求数 |
析构日志一条都没有,use_count 恒 ≥2 | 循环引用,计数永远不会归零 | 打印各对象的 use_count,查 shared_ptr 成员互指;改 weak_ptr |
valgrind 报 definitely lost: 48 bytes in 3 blocks | 明确泄漏,分配点有栈可查 | 用 --leak-check=full 看分配栈,对照代码查异常路径(未实测) |
ASan 报 LeakSanitizer: detected memory leaks / Direct leak of 16 byte(s) | 同上,进程退出时才汇总 | 看报告里的分配栈,从最近一次分配往回找 owner(未实测) |
ASan 报 heap-use-after-free ... READ of size 8 | 对象已释放还在访问,引用/指针悬垂 | 对比 free 点和 read 点的栈;智能指针不保证引用有效(未实测) |
free(): double free detected 或 attempting free on address which was not malloc | 同一裸指针被两个 owner 释放,常见于对同一 raw 指针构造两次 shared_ptr | 确认裸指针只交给一个 shared_ptr,之后一律用 make_shared |
Windows 退出码 -1073741819 / 0xC0000005 | 访问违例,常见于 reset() 或 move 之后继续用 | 查 operator->、get() 解引用前是否判空 |
对象数不变,但容器 size() 只涨不降 | 逻辑泄漏:缓存没上限、历史记录只追加 | 给容器设上限或换 LRU,定期清理,别把它当成 new/delete 问题 |
表里最容易被误判的是最后一条。RSS 高不一定有泄漏,先看对象数量和容器大小;反过来,对象数稳定也不代表没问题,碎片同样会让 RSS 上去。
边界与代价
- shared_ptr 不便宜。两个指针大小,控制块还有两个计数,拷贝要原子操作。热路径上高频拷贝
shared_ptr,开销比想象中大;参数尽量用const shared_ptr<T>&。 - make_shared 会延迟释放。对象和控制块同块分配,只要还有一个
weak_ptr,整块内存都不还。缓存场景里弱引用多,这个延迟值得算。 - unique_ptr 不能共享。它把「所有权唯一」写进了类型,接口设计必须先回答「谁拥有这个对象」。答不出来,说明设计还没想清楚,不是换个智能指针能解决的。
- 循环引用工具默认查不出来。计数非零,泄漏检测器看到的是「仍被引用」,只有做堆图分析才能发现不可达环。防它要靠设计,不是靠工具。
- 智能指针不解决线程安全。它保证对象在有人持有时不释放,不保证成员访问的并发正确性,也不保证你手里的引用在另一线程释放后还有效。
- 碎片和逻辑泄漏容易被误判。频繁分配不同大小的块,RSS 会上去但并未泄漏;缓存无上限则是逻辑问题。两者的解法都不是加智能指针。
- 工具缺位。本机 MinGW 没有 ASan,valgrind 只在 Linux 上跑;Windows 上定位内存问题更多依赖任务管理器、调试器和代码审查,条件不如 Linux 顺手。
当天能验证的练习
- 编译运行
unique_demo,把use(std::move(a))改成use(a),看编译错误原文,理解「所有权不能复制」。 - 跑循环引用示例,确认
use_count停在 2 且没有析构输出;把next改成weak_ptr,观察析构顺序。再把lock()的返回值放在不同作用域,看expired()何时变 1。 - 用自定义删除器包一个
FILE*,打印三种删除器的sizeof;再把 lambda 改成捕获一个计数器,观察类型大小变化。 - 跑 placement new 示例,故意删掉
p->~Item(),观察缺少dtor输出;再试着对buf调delete,看程序怎么结束。 - 跑悬垂引用示例,把
const std::string&改成std::string或存下标,对比输出。若手边有 Linux 环境,用 valgrind 或 ASan 再跑一遍(本机没有,未实测)。
小结
记住三件事:默认 unique_ptr,需要共享才 shared_ptr,反向引用用 weak_ptr;对象的生命周期要在设计里说清楚,工具只能帮你发现,不能替你决定;智能指针保证「有人持有就不释放」,不保证「你手里的引用还有效」。
代码能正确管理内存之后,下一个问题是这些文件怎么组织、怎么编译。现在还是几条 g++ 命令,文件一多、依赖一复杂,命令行就管不过来了。下一篇讲 CMake 和构建流程:目标怎么定义、头文件路径怎么传、Debug 和 Release 怎么切,以及为什么「在我机器上能编译」这句话在 C++ 项目里格外常见。