04.7.6 内存管理与垃圾回收
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python
覆盖范围
- 引用计数、标记清除、分代回收
- pymalloc 与内存归还操作系统
- 弱引用、
__del__、finalize - 常见内存泄漏来源与排查工具
- 峰值内存优化与高效数据结构
04.7.6-001 引用计数是怎么工作的?有什么优缺点?
一句话结论
每个对象头部有 ob_refcnt,被赋值、传参、放入容器时 +1,解绑、离开作用域、容器销毁时 -1;归零立即释放。优点是回收即时、实现简单;缺点是无法处理循环引用、每次增减都有开销、多线程需原子操作。
概念解释
- 引用计数是 CPython 特有,PyPy 用 tracing GC。
- 函数局部变量在帧销毁时统一减引用,容器元素被删除时对应对象减引用。
原理流程
- 对象被赋值、传参、放入容器时引用计数 +1。
- 解绑、离开作用域、容器销毁时 -1。
- 计数归零立即释放;循环引用让计数永不为零,需要 GC 兜底。
代码或图示
import sys
a = []
print(sys.getrefcount(a)) # 2(a + 临时参数)
b = a
print(sys.getrefcount(a)) # 3
常见误区
sys.getrefcount(obj)会临时 +1,因此看到的值通常比实际多 1。- 引用计数不能处理循环引用:两个对象互相引用,外部引用消失后计数仍各为 1;CPython 用 GIL 保证增减原子,free-threading 构建改用原子操作。
追问
- 为什么引用计数不能处理循环引用?答:两个对象互相引用,外部引用消失后计数仍各为 1。
- 引用计数是线程安全的吗?答:CPython 用 GIL 保证增减原子,free-threading 构建改用原子操作。
- 循环引用一定会泄漏吗?答:不一定,分代 GC 会周期性检测并回收,但会有延迟。
04.7.6-002 循环引用是怎么被回收的?标记清除做了什么?
一句话结论
GC 从“根集合”(模块全局、栈帧局部、静态结构)出发遍历可达对象,不可达的循环引用被判定为垃圾并回收。CPython 的分代 GC 只跟踪“容器对象”(list、dict、实例等可能持有引用的对象),用三代链表管理。
概念解释
- 只跟踪容器对象,int/str 等原子对象不参与循环检测。
- 循环引用回收不是即时的,要等阈值触发或手动
gc.collect()。
原理流程
- 标记阶段:从根集合出发标记所有可达对象。
- 清除阶段:未标记的容器对象判定为垃圾并回收。
- 回收时会调用
__del__(若有),顺序不确定。
代码或图示
import gc
class Node:
def __init__(self): self.peer = None
a, b = Node(), Node()
a.peer, b.peer = b, a
del a, b
gc.collect() # 回收这对循环引用
常见误区
- 大量小对象会产生 GC 压力,可通过调整阈值或禁用 GC(谨慎)优化。
- 标记清除会短暂停顿(stop-the-world),Python 的停顿通常很短;手动
gc.collect()适合内存峰值后、批处理结束、对延迟不敏感的时点。
追问
- 为什么只跟踪容器对象?答:原子对象不可能形成循环引用,跟踪它们纯属浪费。
- 标记清除会暂停程序吗?答:会短暂停顿(stop-the-world),Python 的停顿通常很短。
- 什么时候手动
gc.collect()?答:内存峰值后、批处理结束、对延迟不敏感的时点。
04.7.6-003 分代回收的三代是怎么划分的?阈值怎么理解?
一句话结论
新对象在第 0 代;第 0 代回收后存活的对象升到第 1 代,再存活升到第 2 代。默认阈值 (700, 10, 10):第 0 代分配-释放净增 700 次触发一次回收,第 0 代回收 10 次触发第 1 代,第 1 代 10 次触发第 2 代。老对象回收频率低,因为“越老越可能长期存活”。
概念解释
gc.get_threshold()查看,gc.set_threshold()调整;gc.get_count()查看当前各代计数。- 第 2 代是全量回收,成本最高。
原理流程
- 新对象进入第 0 代。
- 某代回收后存活对象晋升到下一代。
- 达到对应代阈值时触发该代回收,越老的代扫描频率越低。
代码或图示
import gc
print(gc.get_threshold()) # (700, 10, 10)
print(gc.get_count())
常见误区
- 阈值不是越大越好,需结合延迟与内存峰值压测;高频创建临时对象的服务可适当调大第 0 代阈值,减少回收次数(但单次更久)。
gc.disable()有风险:循环引用永不回收,长期运行会内存上涨;第 2 代回收对象越多停顿越长,可用gc.freeze()冻结长期对象。
追问
- 为什么分代能提升效率?答:大多数对象很快死亡,只扫描年轻代即可回收大部分垃圾。
- 第 2 代回收会影响延迟吗?答:会,对象越多停顿越长,可用
gc.freeze()冻结长期对象。 gc.disable()有什么风险?答:循环引用永不回收,长期运行会内存上涨。
04.7.6-004 为什么删除了大对象,内存没有还给操作系统?
一句话结论
Python 的内存由 pymalloc 管理:小对象从 arena 里的 pool 分配,del 只把内存还给 allocator,arena 仍被进程持有,不一定 free 给 OS。大对象走 malloc/mmap,通常能归还,但碎片化也会阻止归还。
概念解释
- pymalloc 按 512 字节分界:小于走 pool(8/16/…/512 字节 size class),大于走系统 malloc。
gc.collect()只回收对象,不整理碎片。
原理流程
- 小对象从 arena 的 pool 分配,释放后归还 allocator 空闲池。
- arena 是 256KB 的块,只有整个 arena 全空时才可能释放给 OS。
- 碎片化导致多个 arena 各留几个活对象,谁都无法释放。
代码或图示
import sys
big = bytearray(200 * 1024 * 1024)
del big # 大对象通常能归还
常见误区
- RSS 不下降但 Python 对象数下降,是因为内存回到 allocator 的空闲池,进程仍持有。
- 标准库没有可靠强制归还 API;
malloc_trim(glibc)可尝试,但不跨平台;容器化后看 RSS/working set,Python 层对象统计不能代表实际占用。
追问
- 为什么 RSS 不下降但 Python 对象数下降了?答:内存回到 allocator 的空闲池,进程仍持有。
- 有办法强制归还吗?答:标准库没有可靠 API;
malloc_trim(glibc)可尝试,但不跨平台。 - 容器化后内存指标看哪个?答:看 RSS/working set,Python 层对象统计不能代表实际占用。
04.7.6-005 __del__ 和循环引用有什么关系?
一句话结论
老版本 CPython 中,定义了 __del__ 的对象处于循环引用时无法被回收(gc.garbage),因为 GC 不确定调用顺序。Python 3.4 起(PEP 442)已能在多数情况下回收并调用 __del__,但仍不保证顺序,不应依赖它释放关键资源。
概念解释
__del__执行时对象可能已处于“半销毁”状态,属性可能已被清理。- 复杂对象图建议用
weakref.finalize或显式close()。
原理流程
- GC 判定循环引用不可达后,需要决定
__del__的调用顺序。 - 老版本无法确定顺序时把对象放入
gc.garbage保留。 - PEP 442 后多数情况可回收并调用析构,但顺序仍不保证。
代码或图示
import weakref
class R:
def __init__(self): self.f = open("x.txt")
def close(self): self.f.close()
r = R()
weakref.finalize(r, r.close)
常见误区
__del__抛异常被忽略,只打印到 stderr;解释器退出时__del__可能不执行或执行环境不完整。__del__里不要访问全局变量:解释器退出时模块全局可能已置 None;资源释放推荐with/try-finally/contextlib,__del__只兜底。
追问
- 为什么
__del__里不要访问全局变量?答:解释器退出时模块全局可能已置 None。 finalize比__del__好在哪?答:不阻止回收、可注册多个回调、可显式调用并取消。- 资源释放的推荐方式?答:
with/try-finally/contextlib,__del__只兜底。
04.7.6-006 弱引用有什么用?WeakValueDictionary 适合什么场景?
一句话结论
弱引用不增加引用计数,对象被回收后弱引用自动失效(返回 None 或从容器移除)。适合做缓存、观察者注册表、父子引用避免循环、对象池,让“缓存不阻止回收”。
概念解释
weakref.ref(obj)得到弱引用,调用它返回对象或 None。WeakKeyDictionary常用于给对象附加元数据而不阻止其回收;WeakSet适合监听器集合。
原理流程
- 弱引用不参与引用计数,对象计数不因弱引用增加。
- 对象被回收时,弱引用被通知并失效。
- 弱值字典的值条目在值回收后自动删除。
代码或图示
import weakref
cache = weakref.WeakValueDictionary()
obj = BigObject()
cache["k"] = obj
del obj
print(cache.get("k")) # None,条目已自动移除
常见误区
- 不是所有对象都支持弱引用:
int、str、tuple不支持,__slots__类需加"__weakref__"。 WeakValueDictionary不是线程安全的,多线程需加锁;函数回调可用weakref.WeakMethod绑定方法,避免强引用实例。
追问
- 为什么弱引用能避免循环引用泄漏?答:它不参与引用计数,环被打断。
WeakValueDictionary是线程安全的吗?答:不是,多线程需加锁。- 弱引用能用于函数回调吗?答:用
weakref.WeakMethod绑定方法,避免强引用实例。
04.7.6-007 常见的内存泄漏原因有哪些?
一句话结论
Python 的“泄漏”多是引用未释放:全局/模块级容器只增不减、无界缓存、闭包或回调持有大对象、异常 traceback 持有栈帧、线程/协程未结束、循环引用 + __del__、C 扩展未释放、生成器未关闭、日志 handler 持有缓冲。
概念解释
- 全局字典做缓存但没有淘汰策略,是最常见的业务泄漏。
- 事件监听器注册后未注销,对象永久存活。
原理流程
- 全局/模块级容器持续持有对象引用,使其始终可达。
- 闭包、回调、bound method 强引用捕获的 self、请求上下文、大 buffer。
- 未结束的线程/协程、traceback、生成器帧继续持有局部变量。
代码或图示
# 泄漏
CACHE = {}
def get(k):
if k not in CACHE:
CACHE[k] = load(k)
return CACHE[k]
常见误区
- 有 GC 仍会泄漏:GC 只回收不可达对象,全局容器里的对象仍然可达。
lru_cache(maxsize=None)缓存长尾参数会无限增长;未join的线程持有栈与局部变量;traceback 对象持有帧与局部变量,长期保存异常会拖住整个调用链;单例/类属性持有请求上下文(如 Flaskg用错)。
追问
- 为什么“有 GC 还会泄漏”?答:GC 只回收不可达对象,全局容器里的对象仍然可达。
- 循环引用一定泄漏吗?答:不一定,但会延迟回收并增加峰值内存。
- 怎么区分“缓存”与“泄漏”?答:是否有上限、淘汰策略、可预期的内存曲线。
04.7.6-008 如何排查内存泄漏?工具与流程是什么?
一句话结论
流程:先确认现象(RSS 持续上涨、对象数增长)→ 用 tracemalloc 抓快照对比定位分配点 → objgraph 看对象增长与引用链 → memory_profiler/py-spy mem 看时间线 → 结合代码审查常见的全局容器/回调/缓存。
概念解释
gc.get_objects()可按类型统计数量。- 生产环境注意采样开销,先低采样率再逐步收紧。
原理流程
- 启动后抓基线快照,运行一段时间再抓快照。
- 两次快照
compare_to找增长最多的文件行。 - 用 objgraph 定位增长类型与反向引用链,结合代码审查全局容器/回调/缓存。
代码或图示
import tracemalloc
tracemalloc.start()
snap1 = tracemalloc.take_snapshot()
# ... 跑一段时间 ...
snap2 = tracemalloc.take_snapshot()
for stat in snap2.compare_to(snap1, "lineno")[:5]:
print(stat)
常见误区
- tracemalloc 只统计 Python 层分配,不含解释器与 C 扩展开销,显示总量比 RSS 小。
- 对象数稳定但 RSS 涨,可能是碎片或 C 扩展泄漏,用
pmap/valgrind/malloc_stats;容器里可暴露诊断端点触发快照,或在预发环境复现。
追问
- 为什么 tracemalloc 显示的总量比 RSS 小?答:它只统计 Python 层分配,不含解释器与 C 扩展开销。
- 对象数稳定但 RSS 涨怎么办?答:可能是碎片或 C 扩展泄漏,用
pmap/valgrind/malloc_stats。 - 容器里怎么抓?答:暴露诊断端点触发快照,或在预发环境复现。
04.7.6-009 sys.getsizeof 为什么不等于真实内存占用?
一句话结论
getsizeof 只返回对象自身(含对象头、内部指针/缓冲)的字节数,不含它引用的子对象。容器(list/dict)只算自己的槽位数组,不算元素对象;字符串不算共享的 interned 部分。要算“深内存”需递归求和并去重。
概念解释
- 小整数来自缓存,不额外计入。
- 第三方库
pympler.asizeof可做深统计。
原理流程
getsizeof读取对象自身大小,不遍历引用的子对象。- 容器只统计结构与指针数组。
- 深内存统计需递归求和,并对共享引用去重、处理循环引用。
代码或图示
import sys
print(sys.getsizeof([1, 2, 3])) # 约 88 字节,不含元素
常见误区
- dict 还有稀疏索引与 entry 数组,实际比“键值对 × 2 指针”更大。
- 不能直接用
len估算内存:对象类型差异巨大,int 与自定义实例差几十倍;估算大 list 内存需列表开销 + 元素数 × 指针 + 元素自身大小。
追问
- 为什么同一字符串对象重复出现不重复计费?答:它可能被驻留,多处共享一份。
- 估算大 list 内存怎么做?答:
列表开销 + 元素数 × 指针 + 元素自身大小。 - 为什么不能直接用
len估算?答:对象类型差异巨大,int 与自定义实例差几十倍。
04.7.6-010 __slots__ 能省多少内存?为什么?
一句话结论
普通实例每个都带 __dict__(一个哈希表,空字典也占约 64 字节,且随属性增加扩容),__slots__ 用固定指针数组替代,每个属性一个槽位。典型可省 40%~60% 实例内存,百万级对象时非常可观。
概念解释
- 属性越多,普通类 dict 扩容越贵,slots 保持线性。
dataclass(slots=True)(3.10+)自动生成;热路径属性访问略快(少一次字典查找)。
原理流程
- 普通实例为每个属性动态维护
__dict__哈希表。 - slots 类在类上声明固定槽位,实例用指针数组存储属性。
- 省去字典哈希表的空槽与 hash/key/value 存储。
代码或图示
import sys
class A: pass
class B:
__slots__ = ("x",)
b = B(); b.x = 1
print(sys.getsizeof(A()), sys.getsizeof(b))
常见误区
- slots 代价:不能动态加属性、不能多继承两个非空 slots 类、需要
__weakref__才能弱引用。 - 方法在类上,不占实例槽位;没有
__weakref__槽位的 slots 类不能弱引用,除非显式声明。
追问
- 为什么
__dict__这么贵?答:哈希表要预留空槽,且每个键值对存 hash、key、value。 - slots 类能加方法吗?答:能,方法在类上,不占实例槽位。
- 为什么 slots 类不能弱引用?答:没有
__weakref__槽位,除非显式声明。
04.7.6-011 如何估算一个百万级 list 的内存?
一句话结论
list 本身约 56 字节 + 8 字节/指针(含扩容余量),元素对象另算。若元素是小 int(缓存内),几乎只付指针钱;若元素是字符串或自定义实例,内存由元素主导,需按元素实际大小估算。
概念解释
- 100 万个指针约 8MB,加上扩容余量约 8~10MB。
- 用
array('q')或 NumPy 存数值可压到 8 字节/元素。
原理流程
- 先算 list 指针数组开销(含 1.125 倍扩容余量)。
- 再按元素类型估算元素对象大小。
- 两者相加得到总内存。
代码或图示
import sys
n = 1_000_000
print(sys.getsizeof([0] * n)) # 约 8MB(指针)
print(sys.getsizeof([i for i in range(n)])) # list 指针 + int 对象
常见误区
- 100 万个独立 int(超过 256)每个约 28 字节;短字符串每个约 49~60 字节;自定义实例每个 56 字节 +
__dict__,可能 100 字节以上。 - 大量数值应用
array、NumPy、struct,避免每元素对象开销;动态数组预留空间以减少复制,约为实际长度的 1.125 倍。
追问
[0] * n与[0 for _ in range(n)]内存一样吗?答:指针数组大小相近,但前者共享同一个 0,后者复用缓存小整数,差异不大。- 大量数值该用什么?答:
array、NumPy、struct,避免每元素对象开销。 - 为什么扩容余量会多占内存?答:动态数组预留空间以减少复制,约为实际长度的 1.125 倍。
04.7.6-012 闭包和回调怎么会导致内存滞留?
一句话结论
闭包捕获的变量存放在 cell 里,只要闭包函数存活,cell 里的对象就不会被回收;回调(信号、事件、计时器、线程池任务)若被全局注册表持有,会一直强引用其捕获的 self、请求上下文、大 buffer。
概念解释
- 常见:把
self.method注册为回调,bound method 强引用实例。 - 定时器/线程池任务结束后应清理引用。
原理流程
- 闭包把捕获变量放入 cell,函数存活则 cell 存活。
- 全局注册表持有回调函数,回调强引用捕获的 self 与大对象。
- 引用链不断,对象无法回收。
代码或图示
import weakref
class Handler:
def on_event(self): ...
h = Handler()
weakref.finalize(h, print, "gone")
bus.subscribe(weakref.WeakMethod(h.on_event))
常见误区
functools.partial(obj.method, ...)同样强引用实例;闭包捕获的是变量(cell),外层后续修改会反映到闭包。- 解决方式:注销回调、用
weakref.WeakMethod、缩小捕获范围(只捕需要的字段);回调泄漏用objgraph.show_backrefs看谁持有实例。
追问
- 闭包捕获的是值还是变量?答:变量(cell),外层后续修改会反映到闭包。
- 为什么缩小捕获范围有用?答:少捕一个大对象,就少一条强引用链。
- 回调泄漏怎么发现?答:
objgraph.show_backrefs看谁持有实例。
04.7.6-013 异常 traceback 会持有内存吗?
一句话结论
会。traceback 对象持有帧(frame),帧持有局部变量。若把异常对象长期保存(日志上下文、全局错误列表、Future、sys.excepthook 缓存),整个调用链的局部变量都无法释放,可能拖住大对象。
概念解释
- 帧还会持有
f_locals,包括大 list、DataFrame、请求体。 - 长生命周期对象(连接、会话)不要持有异常。
原理流程
- 异常抛出时生成 traceback 链,每帧保存局部变量。
- 异常对象被长期保存,traceback 链与其局部变量随之存活。
- 需释放时只保留字符串,或调用
traceback.clear_frames(tb)。
代码或图示
import traceback
try:
...
except Exception:
logger.exception("failed")
# 不要把 e / tb 存进全局结构
常见误区
except Exception as e:在 Python 3 中退出 except 块后e被删除,但若return e或存进容器则保留。raise ... from e会通过__cause__保留原异常与 traceback,注意生命周期;日志记录异常用logger.exception输出文本,而不是长期保存异常对象。
追问
- 为什么
traceback.format_exc()是安全的?答:它返回字符串,不持有帧引用。 raise ... from e会保留链吗?答:会,__cause__持有原异常与 traceback,注意生命周期。- 怎么清理帧?答:
traceback.clear_frames(tb)释放局部变量。
04.7.6-014 生成器不消费会造成内存问题吗?
一句话结论
生成器对象本身很小,但它捕获的参数、打开的文件、缓冲区会一直存活到生成器被关闭或回收。若把大量生成器存进列表而不消费、不关闭,等于把资源挂起,可能泄漏句柄与内存。
概念解释
- 生成器帧保存局部变量,包含可能很大的数据结构。
- 异步生成器需
aclose(),否则连接/游标不释放。
原理流程
- 生成器对象持有帧与捕获的参数、文件、缓冲区。
- 未消费、未关闭时这些资源随生成器存活。
close()/GC 时执行finally清理。
代码或图示
gen = (x for x in big_list) # 捕获 big_list
del gen # 释放捕获
常见误区
- 无限生成器被
list()会直接 OOM;生成器表达式会持有原容器,迭代器引用原可迭代对象。 - 建议用
with contextlib.closing(gen)或消费完显式close();异步生成器忘记aclose会导致连接/游标泄漏,事件循环关闭时报未关闭警告。
追问
- 生成器表达式会持有原容器吗?答:会,迭代器引用原可迭代对象。
- 为什么生成器比列表省内存?答:只保留当前元素与迭代状态,不物化全部。
- 异步生成器忘记
aclose会怎样?答:连接/游标泄漏,事件循环关闭时报未关闭警告。
04.7.6-015 如何设计一个不会泄漏的缓存?
一句话结论
必须有容量上限、淘汰策略与过期机制:lru_cache(maxsize=N)、cachetools.LRUCache/TTLCache、WeakValueDictionary(对象可回收时自动清理),并避免把请求级对象放进进程级缓存。
概念解释
- TTL 适合“可容忍短暂不一致”的数据;LRU 适合热点集中。
- 缓存大对象要估算“条目数 × 单条大小”,定内存预算。
原理流程
- 缓存设定条目上限与淘汰策略(LRU/TTL/弱引用)。
- 超限时淘汰最久未用或过期条目。
- key 归一化避免同一逻辑参数产生双份缓存。
代码或图示
from cachetools import TTLCache
cache = TTLCache(maxsize=1024, ttl=300)
常见误区
- 无界缓存等于泄漏,尤其 key 是用户 ID、URL、SQL 这类长尾参数。
- 缓存命中率低时应检查 key 设计、预热、数据分布,而不是一味加容量;多副本本地缓存需接受不一致,或用 Redis 统一。
追问
lru_cache的maxsize怎么定?答:按命中率与内存预算压测确定,别拍脑袋。- 缓存命中率低怎么办?答:检查 key 设计、预热、数据分布,不是一味加容量。
- 弱引用缓存适合什么?答:对象本来就会被别处回收、缓存只是加速的场景。
04.7.6-016 多进程下内存是共享的吗?COW 是什么?
一句话结论
fork 后父子进程共享物理页(写时复制 COW):只读访问不复制,任一进程写入才复制该页。因此“父进程加载大模型再 fork”能省内存;但 Python 的引用计数写入会触发大量页复制,实际共享率会下降。
概念解释
- COW 的粒度是内存页(通常 4KB)。
- spawn 不共享内存,每个进程独立加载。
原理流程
- fork 时内核不复制物理页,标记为只读并共享。
- 某进程写入该页时,内核复制该页并允许各自修改。
- Python 对象头引用计数变动会写页,导致 COW 复制。
代码或图示
from multiprocessing import shared_memory
shm = shared_memory.SharedMemory(create=True, size=10_000_000)
常见误区
- 只读数据结构(大 bytes、只读数组)共享效果好;
shared_memory可显式共享大数组,避免 COW 不确定性。 - 容器内存统计可能把共享页算两次,需看 PSS/USS 而非简单 RSS 求和;引用计数与 GC 会频繁写对象头,导致 Python COW 共享率不高。
追问
- 为什么 Python 的 COW 共享率不高?答:引用计数与 GC 会频繁写对象头。
- 什么数据适合 fork 前加载?答:只读大数组、模型权重(用只读 mmap)。
- 容器内存统计会把共享页算两次吗?答:可能,需看 PSS/USS 而非简单 RSS 求和。
04.7.6-017 如何降低峰值内存?
一句话结论
流式处理替代全量加载、分批/分页、生成器管道、及时 del 与作用域收敛、避免中间副本(list(a)、深拷贝、连续切片)、用 array/NumPy、把大任务拆到子进程并限制并发。
概念解释
- 读文件用逐行或分块,不要
read()全量。 - 并发数与单任务内存相乘就是峰值,需一起控制。
原理流程
- 输入按流/分批进入,不在内存物化全量。
- 转换链用生成器,避免每一步都物化列表。
- 大对象用完立即
del,避免被闭包/全局引用。
代码或图示
def process(path):
with open(path, encoding="utf-8") as f:
for line in f: # 峰值与行长相关
handle(line)
常见误区
del后内存不一定降:内存回到空闲池未归还 OS;数据库用游标/分页,避免fetchall()。- 分批大小按单批处理时间、内存上限、下游超时综合确定;峰值约为“并发数 × 单任务驻留内存”。
追问
- 为什么
del后内存没降?答:见 pymalloc,内存回到空闲池未归还 OS。 - 分批大小怎么定?答:按单批处理时间、内存上限、下游超时综合确定。
- 并发越高内存越高吗?答:是,峰值约为“并发数 × 单任务驻留内存”。
04.7.6-018 深拷贝/序列化会带来多大内存开销?
一句话结论
copy.deepcopy 复制整个对象图,峰值可达原对象的 2 倍;pickle 序列化产生字节流(再加载又是新对象),大对象场景可能是 3 倍峰值。能用不可变共享、只读引用或增量更新时,避免全量复制。
概念解释
- deepcopy 的 memo 表本身也占内存。
- JSON 序列化会产生中间字符串,大响应要流式输出。
原理流程
- 深拷贝遍历对象图创建副本,原对象与副本同时存活。
- 序列化生成字节流,内存中同时存在原对象与字节流。
- 加载后再生成新对象,三份叠加形成峰值。
代码或图示
import copy, pickle
clone = copy.deepcopy(obj)
blob = pickle.dumps(obj, protocol=pickle.HIGHEST_PROTOCOL)
常见误区
- 复制前后同时存活的对象造成峰值叠加;大批量处理时可分片复制、处理完立即释放。
- pickle 协议版本影响体积与速度,
protocol=5通常更小更快;只改外层结构、内部元素不需独立时可用浅拷贝。
追问
- 为什么深拷贝后内存不立刻降?答:原对象仍被引用,两份同时存在。
- 什么时候可以用浅拷贝?答:只改外层结构、内部元素不需独立时。
- 大对象跨进程怎么传更省?答:共享内存、文件、或传 ID 让子进程自取。
04.7.6-019 内存和 GIL、多线程有什么关系?
一句话结论
GIL 让多线程不能并行计算,但每个线程仍有独立栈(约 8MB 虚拟内存)与帧对象;线程越多,内存与切换开销越大。多进程则每个进程独立解释器与堆,内存成倍增长(除 COW 共享部分)。
概念解释
- 线程栈大小可调(
threading.stack_size()),但过小会栈溢出。 - 协程的“栈”在堆上,单任务开销远小于线程。
原理流程
- 每创建一个线程分配独立内核栈与帧链。
- 多进程各自创建解释器与独立堆。
- 协程任务对象在堆上,无独立内核栈,单任务更轻。
代码或图示
threading.stack_size(512 * 1024) # 谨慎调小
常见误区
- 多进程优势是并行,代价是内存翻倍与 IPC;容量规划要把“进程数 × 单进程内存”算进去。
- 线程数过多会 OOM:栈与帧对象都占内存,且调度开销上升;深递归占用更多栈内存。
追问
- 为什么协程能开上万而线程不能?答:协程无独立内核栈,任务对象更轻。
- 多进程内存怎么估?答:单进程 RSS × 进程数,减去 COW 共享部分。
- 线程数过多会 OOM 吗?答:会,栈与帧对象都占内存,且调度开销上升。
04.7.6-020 如何用 gc.freeze() 优化启动后内存与停顿?
一句话结论
gc.freeze() 把当前所有被跟踪对象移入“永久代”,之后的回收不再扫描它们,适合“启动后大量长期对象已就绪”的服务(如加载完配置、模型、路由表)。能减少 GC 扫描量与停顿,但冻结后这些对象不再参与循环回收。
概念解释
- 典型用法:应用初始化完成后调用一次
gc.freeze()。 - 与
gc.unfreeze()成对使用(测试/热重载)。
原理流程
- 初始化完成后先
gc.collect()清理临时对象。 freeze()把当前被跟踪对象移入永久代链表。- 后续 GC 只扫描新产生的对象,冻结批次不再遍历。
代码或图示
import gc
gc.collect()
gc.freeze() # 初始化完成后
常见误区
- 冻结对象若形成循环引用且不可达,将不会被回收,需谨慎。
- 冻结后新对象还会被回收;效果需用
gc.get_stats()与延迟指标验证;频繁创建/销毁大对象、或需要精确回收内存的场景不该冻结。
追问
- 冻结后新对象还会被回收吗?答:会,只有冻结的那批不扫描。
- 为什么能降低停顿?答:每次回收遍历的对象集变小。
- 什么时候不该冻结?答:频繁创建/销毁大对象、或需要精确回收内存的场景。
04.7.6-021 tracemalloc 和 memory_profiler 怎么选?
一句话结论
tracemalloc 是标准库,按分配点统计 Python 层内存、支持快照对比,开销可控,适合定位“哪一行在涨”;memory_profiler 逐行采样进程 RSS,直观但开销大,适合小脚本或离线分析。
概念解释
- tracemalloc 可设
frames=25保留调用栈深度。 - 两者都看不到 C 扩展内部的内存分配。
原理流程
- tracemalloc 记录每次 Python 分配的栈帧与大小,快照对比定位增长行。
- memory_profiler 定时采样进程 RSS,按行输出时间线曲线。
- 生产优先低开销的 tracemalloc + objgraph,离线用 memory_profiler。
代码或图示
tracemalloc.start(25)
...
print(tracemalloc.get_traced_memory()) # (current, peak)
常见误区
- tracemalloc 每次分配记录栈帧,通常有 10%~30% 开销,需按需开启。
memory_profiler的@profile需要装饰器或-m memory_profiler;C 扩展泄漏用 valgrind/massif、malloc_stats、或逐步二分定位。
追问
- 为什么 tracemalloc 有开销?答:每次分配记录栈帧,通常 10%~30%,需按需开启。
- 峰值内存怎么看?答:
get_traced_memory()的第二个返回值是峰值。 - C 扩展泄漏怎么查?答:valgrind/massif、
malloc_stats、或逐步二分定位。
04.7.6-022 长期运行的服务内存缓慢上涨,怎么定位?
一句话结论
先画曲线确认“阶梯式上涨”还是“持续线性上涨”:阶梯多为缓存/对象累积,线性更像 C 扩展或连接泄漏。再用 tracemalloc 快照对比、objgraph 看类型增长、检查线程/协程/连接数、最后用二分法关闭模块定位。
概念解释
- 对象数(
gc.get_objects()按类型计数)比 RSS 更能反映 Python 层泄漏。 - 复现环境用相同流量回放,逐步关闭功能二分。
原理流程
- 记录启动后基线 RSS,按小时采样画曲线形态。
- 统计各类型对象数量、全局容器长度、缓存条目数、线程数、打开 fd 数。
- 快照对比与二分关闭模块,锁定泄漏来源。
代码或图示
import gc, collections
counts = collections.Counter(type(o).__name__ for o in gc.get_objects())
print(counts.most_common(10))
常见误区
- 对象数不涨但 RSS 涨,是碎片化或 C 层分配,需系统级工具。
- 连接泄漏特征:fd 数持续上涨、TIME_WAIT 增多、下游报连接数超限;定时任务/重试每次创建新客户端未关闭是常见点;重启只是兜底手段,同时必须继续定位根因。
追问
- 为什么对象数不涨但 RSS 涨?答:碎片化或 C 层分配,需系统级工具。
- 连接泄漏有什么特征?答:fd 数持续上涨、TIME_WAIT 增多、下游报连接数超限。
- 什么时候重启是合理方案?答:兜底手段,同时必须继续定位根因。
04.7.6-023 为什么大量小对象会拖慢程序?
一句话结论
每个对象有头部(引用计数 + 类型指针)与分配/回收成本,大量小对象导致分配器压力、GC 扫描量增加、缓存局部性变差。解决:用 __slots__、array/NumPy、批量数据结构、避免临时对象与字符串拼接。
概念解释
- GC 每代扫描容器对象,对象越多停顿越长。
- 用元组/
namedtuple/__slots__降低单对象开销。
原理流程
- 小对象在 arena/pool 中分配,跨 pool 访问缓存不友好。
- 大量容器对象进入 GC 跟踪链,每代扫描量上升。
- 循环内临时 dict/list 增加分配与回收压力。
代码或图示
# 差:每个点一个 dict
points = [{"x": x, "y": y} for x, y in data]
# 好:元组或 slots
points = [(x, y) for x, y in data]
常见误区
- dict 是哈希表,有索引与 entry 数组,比 tuple(定长指针数组)贵很多。
- 对象池对高频创建销毁的固定类型有效,但 Python 对象池实现复杂,优先减少对象;字符串拼接产生大量中间对象,
join可减少;热点在 Python 层且对象开销占主导时再考虑 C 扩展。
追问
- 为什么 dict 比 tuple 贵很多?答:dict 是哈希表,有索引与 entry 数组,tuple 只是定长指针数组。
- 对象池有用吗?答:对高频创建销毁的固定类型有效,但 Python 对象池实现复杂,优先减少对象。
- 什么时候考虑 C 扩展?答:热点在 Python 层且对象开销占主导时。
04.7.6-024 如何判断一段代码是否“内存友好”?
一句话结论
看三点:峰值是否与输入规模线性(还是有额外副本)、是否流式处理、是否有稳定的释放路径。做法:用 tracemalloc 量峰值、检查是否全量加载/深拷贝/中间列表、确认 with/close/生成器关闭都有。
概念解释
- 输入 1GB 文件,峰值应接近块大小,而不是 1GB+。
- 并发时峰值 = 并发数 × 单任务内存,需一起评估。
原理流程
- 用 tracemalloc 记录峰值与当前占用。
- 检查是否全量加载、深拷贝、中间列表叠加。
- 确认正常与异常路径都有资源释放路径。
代码或图示
tracemalloc.start()
run()
print(tracemalloc.get_traced_memory()) # 观察 peak
常见误区
- 转换链每步都物化列表会让峰值叠加;缓存/全局容器是否随输入增长而无上限需重点检查。
- 失败时的资源未释放会累积成泄漏;流式处理通常更省内存,但可能增加 IO 次数与延迟,需要权衡。
追问
- 峰值和平均值哪个更重要?答:峰值决定 OOM 风险,平均值决定长期占用。
- 为什么要关注异常路径?答:失败时的资源未释放会累积成泄漏。
- 流式处理一定更省内存吗?答:是,但可能增加 IO 次数与延迟,需要权衡。
04.7.6-025 高效数据结构怎么选?
一句话结论
数值密集用 array/NumPy;两端操作用 deque;大量键值用 dict(必要时 __slots__ 值对象);只读配置用 tuple/frozenset(可哈希、省内存);集合运算用 set;固定字段记录用 namedtuple/dataclass(slots=True)。
概念解释
list适合通用序列,元素是对象指针。frozenset可哈希,适合做 key 或常量集合。
原理流程
- 按访问模式(两端、按键、集合运算、固定字段)选结构。
- 数值密集选择原始类型数组,避免每元素对象开销。
- 只读常量选择不可变可哈希结构。
代码或图示
from array import array
from collections import deque
v = array("d", [1.0, 2.0]) # 8 字节/元素
q = deque(maxlen=1000) # 自动淘汰旧元素
常见误区
array按 typecode 存原始数值,内存省 4~8 倍,但只支持数值/字符单类型;deque两端 O(1),中间插入仍 O(n)。- dict 查找 O(1) 但内存开销大,超大数据可考虑分片或外部存储;
deque(maxlen=N)满时自动从另一端淘汰,适合滑动窗口。
追问
- 为什么
deque(maxlen=N)适合滑动窗口?答:满时自动从另一端淘汰,O(1)。 array能存字符串吗?答:不能,typecode 只支持数值/字符单类型。- 什么时候用
frozenset做缓存 key?答:需要把“一组标签”作为可哈希键时。
本节高频题
- 引用计数(001)
- 循环引用与标记清除(002)
- 分代回收与阈值(003)
- 内存不归还 OS(004)
__del__与finalize(005)- 弱引用与缓存(006、015)
- 泄漏原因清单(007)
- 排查工具与流程(008、022)
getsizeof局限(009)__slots__省内存(010)- traceback 持有帧(013)
- 峰值内存优化(017)