一个后台服务上线时 RSS 是 200MB,跑一周涨到 2GB,重启立刻回到 200MB。CPU 正常,QPS 正常,日志里没有 OOM,也没有崩溃。运维问是不是内存泄漏,开发第一反应是「代码里没有 new」。

另一个服务更安静:两个模块互相注册回调,都拿 shared_ptr 持有对方。打印 use_count 一直是 2,析构函数从来没执行过。服务不崩,内存每天涨一点,直到某次发布重启才「恢复」。

这篇讲清这两件事:对象住在栈、堆还是静态区;为什么默认用 unique_ptr;make_unique 和 make_shared 省了什么;shared_ptr 的计数为什么停在 2;自定义删除器怎么写;裸 new/delete 还剩哪些必要场景;以及智能指针也解决不了的悬垂引用。

本文按 C++20 写。示例在本机 Windows + MinGW g++ 16.2.0 上实际编译运行过,命令和输出照抄可用。本机没有 valgrind 和 ASan,相关工具的输出在文中只作示例,均标注未实测。

现象:只涨不降,和「不析构」

先分清三种「涨」。真泄漏的特征是 RSS 随请求单调上涨、重启归零、压测停止后也不明显下降;缓存的特征是涨到某个水位后平稳,重启后重新爬升;内存碎片的特征是小块分配很多、RSS 高但堆里没有对应的大对象。三者处理方式完全不同,先分类再动手。

循环引用的特征更具体:该析构的对象没析构。在所有析构函数里打一行日志,正常退出时应该能看到每个对象收尾;如果一条都没有,先怀疑所有权成环,而不是去查 new 和 delete 有没有配对。

排查顺序永远是先量再猜:RSS、容器 size()、对象计数、分配次数。没有度量就改代码,等于闭眼修车。

栈、堆、静态存储:对象到底住在哪

栈:函数局部变量和参数,进函数分配、出函数释放,地址连续,大小有限
堆:new / malloc 来的内存,生命周期由代码决定,分配慢,可能产生碎片
静态存储:全局变量和函数内 static,程序启动时构造,main 结束后析构
常量与代码区:只读数据和指令,通常不参与业务对象的生命周期讨论

写个小程序把析构时机打出来:

#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++ 项目里格外常见。