罗罗编程学习记录
本页内容 展开查看

04.7.6 内存管理与垃圾回收

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python

覆盖范围

  • 引用计数、标记清除、分代回收
  • pymalloc 与内存归还操作系统
  • 弱引用、__del__、finalize
  • 常见内存泄漏来源与排查工具
  • 峰值内存优化与高效数据结构

04.7.6-001 引用计数是怎么工作的?有什么优缺点?

一句话结论

每个对象头部有 ob_refcnt,被赋值、传参、放入容器时 +1,解绑、离开作用域、容器销毁时 -1;归零立即释放。优点是回收即时、实现简单;缺点是无法处理循环引用、每次增减都有开销、多线程需原子操作。

概念解释

  • 引用计数是 CPython 特有,PyPy 用 tracing GC。
  • 函数局部变量在帧销毁时统一减引用,容器元素被删除时对应对象减引用。

原理流程

  1. 对象被赋值、传参、放入容器时引用计数 +1。
  2. 解绑、离开作用域、容器销毁时 -1。
  3. 计数归零立即释放;循环引用让计数永不为零,需要 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()。

原理流程

  1. 标记阶段:从根集合出发标记所有可达对象。
  2. 清除阶段:未标记的容器对象判定为垃圾并回收。
  3. 回收时会调用 __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 代是全量回收,成本最高。

原理流程

  1. 新对象进入第 0 代。
  2. 某代回收后存活对象晋升到下一代。
  3. 达到对应代阈值时触发该代回收,越老的代扫描频率越低。

代码或图示

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() 只回收对象,不整理碎片。

原理流程

  1. 小对象从 arena 的 pool 分配,释放后归还 allocator 空闲池。
  2. arena 是 256KB 的块,只有整个 arena 全空时才可能释放给 OS。
  3. 碎片化导致多个 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()。

原理流程

  1. GC 判定循环引用不可达后,需要决定 __del__ 的调用顺序。
  2. 老版本无法确定顺序时把对象放入 gc.garbage 保留。
  3. 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 适合监听器集合。

原理流程

  1. 弱引用不参与引用计数,对象计数不因弱引用增加。
  2. 对象被回收时,弱引用被通知并失效。
  3. 弱值字典的值条目在值回收后自动删除。

代码或图示

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 持有缓冲。

概念解释

  • 全局字典做缓存但没有淘汰策略,是最常见的业务泄漏。
  • 事件监听器注册后未注销,对象永久存活。

原理流程

  1. 全局/模块级容器持续持有对象引用,使其始终可达。
  2. 闭包、回调、bound method 强引用捕获的 self、请求上下文、大 buffer。
  3. 未结束的线程/协程、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 对象持有帧与局部变量,长期保存异常会拖住整个调用链;单例/类属性持有请求上下文(如 Flask g 用错)。

追问

  • 为什么“有 GC 还会泄漏”?答:GC 只回收不可达对象,全局容器里的对象仍然可达。
  • 循环引用一定泄漏吗?答:不一定,但会延迟回收并增加峰值内存。
  • 怎么区分“缓存”与“泄漏”?答:是否有上限、淘汰策略、可预期的内存曲线。

04.7.6-008 如何排查内存泄漏?工具与流程是什么?

一句话结论

流程:先确认现象(RSS 持续上涨、对象数增长)→ 用 tracemalloc 抓快照对比定位分配点 → objgraph 看对象增长与引用链 → memory_profiler/py-spy mem 看时间线 → 结合代码审查常见的全局容器/回调/缓存。

概念解释

  • gc.get_objects() 可按类型统计数量。
  • 生产环境注意采样开销,先低采样率再逐步收紧。

原理流程

  1. 启动后抓基线快照,运行一段时间再抓快照。
  2. 两次快照 compare_to 找增长最多的文件行。
  3. 用 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 可做深统计。

原理流程

  1. getsizeof 读取对象自身大小,不遍历引用的子对象。
  2. 容器只统计结构与指针数组。
  3. 深内存统计需递归求和,并对共享引用去重、处理循环引用。

代码或图示

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+)自动生成;热路径属性访问略快(少一次字典查找)。

原理流程

  1. 普通实例为每个属性动态维护 __dict__ 哈希表。
  2. slots 类在类上声明固定槽位,实例用指针数组存储属性。
  3. 省去字典哈希表的空槽与 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 字节/元素。

原理流程

  1. 先算 list 指针数组开销(含 1.125 倍扩容余量)。
  2. 再按元素类型估算元素对象大小。
  3. 两者相加得到总内存。

代码或图示

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 强引用实例。
  • 定时器/线程池任务结束后应清理引用。

原理流程

  1. 闭包把捕获变量放入 cell,函数存活则 cell 存活。
  2. 全局注册表持有回调函数,回调强引用捕获的 self 与大对象。
  3. 引用链不断,对象无法回收。

代码或图示

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、请求体。
  • 长生命周期对象(连接、会话)不要持有异常。

原理流程

  1. 异常抛出时生成 traceback 链,每帧保存局部变量。
  2. 异常对象被长期保存,traceback 链与其局部变量随之存活。
  3. 需释放时只保留字符串,或调用 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(),否则连接/游标不释放。

原理流程

  1. 生成器对象持有帧与捕获的参数、文件、缓冲区。
  2. 未消费、未关闭时这些资源随生成器存活。
  3. 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 适合热点集中。
  • 缓存大对象要估算“条目数 × 单条大小”,定内存预算。

原理流程

  1. 缓存设定条目上限与淘汰策略(LRU/TTL/弱引用)。
  2. 超限时淘汰最久未用或过期条目。
  3. 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 不共享内存,每个进程独立加载。

原理流程

  1. fork 时内核不复制物理页,标记为只读并共享。
  2. 某进程写入该页时,内核复制该页并允许各自修改。
  3. 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() 全量。
  • 并发数与单任务内存相乘就是峰值,需一起控制。

原理流程

  1. 输入按流/分批进入,不在内存物化全量。
  2. 转换链用生成器,避免每一步都物化列表。
  3. 大对象用完立即 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 序列化会产生中间字符串,大响应要流式输出。

原理流程

  1. 深拷贝遍历对象图创建副本,原对象与副本同时存活。
  2. 序列化生成字节流,内存中同时存在原对象与字节流。
  3. 加载后再生成新对象,三份叠加形成峰值。

代码或图示

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()),但过小会栈溢出。
  • 协程的“栈”在堆上,单任务开销远小于线程。

原理流程

  1. 每创建一个线程分配独立内核栈与帧链。
  2. 多进程各自创建解释器与独立堆。
  3. 协程任务对象在堆上,无独立内核栈,单任务更轻。

代码或图示

threading.stack_size(512 * 1024)    # 谨慎调小

常见误区

  • 多进程优势是并行,代价是内存翻倍与 IPC;容量规划要把“进程数 × 单进程内存”算进去。
  • 线程数过多会 OOM:栈与帧对象都占内存,且调度开销上升;深递归占用更多栈内存。

追问

  • 为什么协程能开上万而线程不能?答:协程无独立内核栈,任务对象更轻。
  • 多进程内存怎么估?答:单进程 RSS × 进程数,减去 COW 共享部分。
  • 线程数过多会 OOM 吗?答:会,栈与帧对象都占内存,且调度开销上升。

04.7.6-020 如何用 gc.freeze() 优化启动后内存与停顿?

一句话结论

gc.freeze() 把当前所有被跟踪对象移入“永久代”,之后的回收不再扫描它们,适合“启动后大量长期对象已就绪”的服务(如加载完配置、模型、路由表)。能减少 GC 扫描量与停顿,但冻结后这些对象不再参与循环回收。

概念解释

  • 典型用法:应用初始化完成后调用一次 gc.freeze()。
  • 与 gc.unfreeze() 成对使用(测试/热重载)。

原理流程

  1. 初始化完成后先 gc.collect() 清理临时对象。
  2. freeze() 把当前被跟踪对象移入永久代链表。
  3. 后续 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 扩展内部的内存分配。

原理流程

  1. tracemalloc 记录每次 Python 分配的栈帧与大小,快照对比定位增长行。
  2. memory_profiler 定时采样进程 RSS,按行输出时间线曲线。
  3. 生产优先低开销的 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 层泄漏。
  • 复现环境用相同流量回放,逐步关闭功能二分。

原理流程

  1. 记录启动后基线 RSS,按小时采样画曲线形态。
  2. 统计各类型对象数量、全局容器长度、缓存条目数、线程数、打开 fd 数。
  3. 快照对比与二分关闭模块,锁定泄漏来源。

代码或图示

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__ 降低单对象开销。

原理流程

  1. 小对象在 arena/pool 中分配,跨 pool 访问缓存不友好。
  2. 大量容器对象进入 GC 跟踪链,每代扫描量上升。
  3. 循环内临时 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+。
  • 并发时峰值 = 并发数 × 单任务内存,需一起评估。

原理流程

  1. 用 tracemalloc 记录峰值与当前占用。
  2. 检查是否全量加载、深拷贝、中间列表叠加。
  3. 确认正常与异常路径都有资源释放路径。

代码或图示

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 或常量集合。

原理流程

  1. 按访问模式(两端、按键、集合运算、固定字段)选结构。
  2. 数值密集选择原始类型数组,避免每元素对象开销。
  3. 只读常量选择不可变可哈希结构。

代码或图示

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)