Python最常考的面试题2——内存管理核心：引用计数与垃圾回收的底层原理全解析

玄同765

发布于 2026-01-14 13:35:49

770

文章被收录于专栏：大模型开发-技术博客大模型开发-技术博客

核心价值：彻底拆解 Python 引用计数、垃圾回收的底层机制、触发条件、调优策略，解决 "内存泄漏"、"GC 卡顿" 等生产级问题。

引言：Python 为什么不会内存泄漏？

你是否有过这样的疑问：

为什么 Python 程序运行时内存会自动管理，无需手动free()？
为什么创建的对象在不再使用时会自动消失？
为什么有时候 Python 程序会出现 "突然卡顿"？

这些问题的答案，都在于 Python 的自动内存管理机制—— 它由两部分组成：

引用计数：实时跟踪对象的引用数量，当引用数为 0 时立即回收对象；
垃圾回收：处理引用计数无法解决的 "循环引用" 问题，定期扫描回收不再使用的对象。

这两种机制相互配合，保证了 Python 程序的内存安全和效率。本文将从底层原理、代码验证、调优策略三个维度，彻底解析 Python 的内存管理。

一、引用计数：Python 内存管理的 "实时守护者"

1.1 什么是引用计数？

引用计数是 Python 最基础、最核心的内存管理机制。每个 Python 对象都有一个引用计数计数器，记录当前有多少个引用指向该对象。当计数器为0时，对象立即被回收，内存被释放。

1.2 引用计数的增减规则

操作类型	引用计数 + 1	引用计数 - 1
赋值操作	x = obj	del x
函数传参	func(obj)	函数执行完毕
添加到容器	lst.append(obj)	lst.remove(obj)
作为容器元素	tuple(obj)	容器被回收

1.3 代码验证：手动查看引用计数

可以用sys.getrefcount()函数查看对象的引用计数：

注意：getrefcount()本身会增加对象的引用计数（因为它将对象作为参数传递），因此实际引用计数是返回值 - 1。

代码验证 1：基本引用计数

import sys

# 创建对象，引用计数=1
x = "hello"
print(f"x的引用计数：{sys.getrefcount(x) - 1}")  # 1

# 赋值操作，引用计数+1 → 2
y = x
print(f"x的引用计数：{sys.getrefcount(x) - 1}")  # 2

# 添加到列表，引用计数+1 → 3
lst = [x]
print(f"x的引用计数：{sys.getrefcount(x) - 1}")  # 3

# 删除y，引用计数-1 → 2
del y
print(f"x的引用计数：{sys.getrefcount(x) - 1}")  # 2

# 从列表中删除，引用计数-1 → 1
lst.remove(x)
print(f"x的引用计数：{sys.getrefcount(x) - 1}")  # 1

# 删除x，引用计数-1 → 0
del x
# print(f"x的引用计数：{sys.getrefcount(x) - 1}")  # 报错：x未定义，对象已被回收

代码验证 2：函数传参的引用计数

import sys

def func(obj):
    print(f"函数内obj的引用计数：{sys.getrefcount(obj) - 1}")  # 2（函数内1个引用+getrefcount的临时引用）

x = "hello"
print(f"函数外x的引用计数：{sys.getrefcount(x) - 1}")  # 1
func(x)
print(f"函数外x的引用计数：{sys.getrefcount(x) - 1}")  # 1（函数执行完毕，引用计数恢复）

1.4 引用计数的优缺点

优点：

实时性：对象的内存会立即被回收，无需等待；
效率高：引用计数的增减是 **O (1)** 操作，开销极小；
简单易懂：实现逻辑简单，容易理解。

缺点：

循环引用：当两个或多个对象相互引用时，引用计数永远不会为 0，导致内存泄漏；
开销：每个对象都需要维护一个计数器，且每次操作都要更新计数器，对 CPU 有一定开销；
无法处理大对象：如果一个对象占据了大量内存，实时回收可能导致程序卡顿。

二、循环引用：引用计数的 "死穴"

2.1 什么是循环引用？

当两个或多个对象相互引用，且没有其他外部引用指向它们时，就会形成循环引用。此时每个对象的引用计数都至少为 1，因此引用计数机制无法回收这些对象，导致内存泄漏。

代码验证：循环引用导致内存泄漏

import sys
import gc

# 关闭自动GC，方便观察
gc.disable()

class Node:
    def __init__(self):
        self.next = None

# 创建两个节点，形成循环引用
a = Node()
b = Node()
a.next = b
b.next = a

# 查看引用计数
print(f"a的引用计数：{sys.getrefcount(a) - 1}")  # 2（a本身+next引用）
print(f"b的引用计数：{sys.getrefcount(b) - 1}")  # 2（b本身+next引用）

# 删除外部引用
del a
del b

# 此时节点a和b已无外部引用，但由于循环引用，引用计数仍为1
# 手动调用GC
gc.collect()

# 查看未回收的对象数量（假设只有这两个节点）
print(f"未回收的对象数量：{len(gc.garbage)}")  # 0（手动GC已回收）

2.2 循环引用的类型

双向循环引用：A→B→A；
多对象循环引用：A→B→C→A；
嵌套对象循环引用：列表a = [b]，b = [a]。

代码验证：嵌套列表循环引用

import sys
import gc

gc.disable()
a = []
b = []
a.append(b)
b.append(a)

print(f"a的引用计数：{sys.getrefcount(a) - 1}")  # 2
print(f"b的引用计数：{sys.getrefcount(b) - 1}")  # 2

del a
del b

# 循环引用，引用计数不为0
gc.collect()
print(f"未回收的对象数量：{len(gc.garbage)}")  # 0

三、垃圾回收：解决循环引用的 "终极武器"

为了解决循环引用的问题，Python 引入了分代垃圾回收机制，通过定期扫描内存，识别并回收循环引用的对象。

3.1 分代垃圾回收的核心思想

分代垃圾回收基于 **"对象存活时间越长，越不可能被回收"** 的统计规律，将对象分为 3 代：

第 0 代：新创建的对象（存活时间 < 1 次 GC）；
第 1 代：经过 1 次 GC 存活下来的对象；
第 2 代：经过 2 次及以上 GC 存活下来的对象。

3.2 分代垃圾回收的触发条件

第 0 代：当新创建的对象数量超过阈值时，触发第 0 代 GC（默认阈值为 700）；
第 1 代：当第 0 代 GC 进行一定次数后，触发第 1 代 GC；
第 2 代：当第 1 代 GC 进行一定次数后，触发第 2 代 GC。

3.3 代码验证：分代 GC 的触发

import gc
import sys

# 查看默认阈值
print(f"第0代阈值：{gc.get_threshold()[0]}")  # 700
print(f"第1代阈值：{gc.get_threshold()[1]}")  # 10
print(f"第2代阈值：{gc.get_threshold()[2]}")  # 10

# 手动设置阈值
gc.set_threshold(1000, 20, 20)
print(f"修改后第0代阈值：{gc.get_threshold()[0]}")  # 1000

# 创建对象，触发第0代GC
for i in range(1000):
    obj = object()

print(f"第0代GC执行次数：{gc.get_count()[0]}")  # 0（触发后重置为0）
print(f"第1代GC执行次数：{gc.get_count()[1]}")  # 1（累计1次第0代GC）

3.4 垃圾回收的算法：标记 - 清除

Python 的垃圾回收采用标记 - 清除算法，分为两个阶段：

标记阶段：从 "根对象"（全局变量、栈上的引用等）出发，标记所有可达的对象；
清除阶段：回收所有未被标记的对象。

代码验证：标记 - 清除算法

import gc
import sys

gc.disable()

# 创建循环引用
a = []
b = []
a.append(b)
b.append(a)

# 标记-清除
gc.collect()

print(f"未回收的对象：{len(gc.garbage)}")  # 0

四、内存泄漏与调试

4.1 什么是内存泄漏？

内存泄漏是指不再使用的对象仍然占据内存，导致程序占用的内存越来越大，最终可能导致系统崩溃。

4.2 常见的内存泄漏场景

循环引用：对象之间相互引用，且无外部引用；
全局变量：长期存在的全局变量，忘记删除；
缓存：缓存的对象太多，没有过期策略；
资源未关闭：文件、数据库连接、网络连接等未关闭；
第三方库：使用的第三方库存在内存泄漏。

4.3 内存泄漏的调试工具

4.3.1 `gc`模块

可以用gc模块的gc.garbage属性查看未回收的对象，用gc.collect()手动触发 GC：

import gc

gc.enable()
gc.set_debug(gc.DEBUG_LEAK)  # 开启泄漏调试

# 创建循环引用
class Node:
    def __init__(self):
        self.next = None

a = Node()
b = Node()
a.next = b
b.next = a

del a
del b

gc.collect()
print(f"泄漏的对象：{gc.garbage}")  # 输出泄漏的对象

4.3.2 `tracemalloc`模块

tracemalloc模块用于跟踪内存分配，可以查看程序在哪个位置分配了最多的内存：

import tracemalloc

# 开始跟踪
tracemalloc.start()

# 模拟内存泄漏
leak_list = []
for i in range(10000):
    leak_list.append("x" * 1024)  # 分配1KB内存

# 查看内存使用情况
snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics("lineno")

print(f"前5个内存分配位置：")
for stat in top_stats[:5]:
    print(stat)

运行结果示例：

前5个内存分配位置：
test.py:9: size=9840 KiB, count=9773, average=1024 B

4.3.3 第三方工具

PySizer：用于分析 Python 程序的内存使用情况；
Guppy-PE：用于查看对象的引用计数和内存占用；
Memory_profiler：用于逐行分析函数的内存使用情况。

五、Python 内存管理的调优策略

5.1 避免循环引用

尽量用不可变类型替代可变类型；
使用weakref模块创建弱引用：弱引用不会增加对象的引用计数，对象被回收后，弱引用自动失效。

代码验证：weakref 弱引用

import sys
import weakref

class Node:
    def __init__(self):
        self.data = "test"

a = Node()
b = weakref.ref(a)  # 创建弱引用

print(f"a的引用计数：{sys.getrefcount(a) - 1}")  # 1
print(f"b()的内容：{b()}")  # <__main__.Node object at 0x000001>

# 删除a，对象被回收
del a
print(f"b()的内容：{b()}")  # None（对象已被回收）

5.2 减少全局变量

全局变量会长期存在于内存中，尽量用局部变量替代；
若必须使用全局变量，在不再使用时及时删除。

代码验证：全局变量与局部变量

# 全局变量：长期存在
global_list = []

def func():
    # 局部变量：函数执行完毕后自动回收
    local_list = []
    for i in range(1000):
        local_list.append("test")

func()

5.3 合理使用缓存

缓存的对象数量不要太多，设置过期策略；
使用functools.lru_cache装饰器实现自动过期的缓存。

代码验证：lru_cache 自动过期

from functools import lru_cache

# 缓存最近5个调用结果
@lru_cache(maxsize=5)
def fib(n):
    if n <= 1:
        return n
    return fib(n-1) + fib(n-2)

print(fib(10))  # 55
print(fib.cache_info())  # CacheInfo(hits=8, misses=11, maxsize=5, currsize=5)

5.4 关闭资源

及时关闭文件、数据库连接、网络连接等资源；
使用上下文管理器（with语句）自动关闭资源。

代码验证：上下文管理器自动关闭

# 错误：忘记关闭文件
f = open("test.txt", "w")
f.write("test")
# f.close()  # 忘记关闭

# 正确：上下文管理器自动关闭
with open("test.txt", "w") as f:
    f.write("test")
# 文件自动关闭

5.5 调整 GC 阈值

若程序需要处理大量短期对象，可以提高第 0 代阈值，减少 GC 触发次数；
若程序需要处理大量长期对象，可以降低第 1 代和第 2 代阈值，提高 GC 频率。

代码验证：调整 GC 阈值

import gc

# 获取当前阈值
print(f"当前阈值：{gc.get_threshold()}")  # (700, 10, 10)

# 调整阈值
gc.set_threshold(1000, 20, 20)
print(f"调整后阈值：{gc.get_threshold()}")  # (1000, 20, 20)

六、总结

Python 的内存管理机制是一个高效、自动的系统，它由引用计数和分代垃圾回收两部分组成：

引用计数负责实时回收不再使用的对象；
分代垃圾回收负责处理循环引用，定期扫描内存；

为了写出高效、无内存泄漏的 Python 代码，你需要：

理解引用计数的增减规则，避免循环引用；
合理使用弱引用和上下文管理器；
及时删除全局变量和关闭资源；
调整GC 阈值以适应程序的需求；
使用调试工具及时发现内存泄漏。

希望这篇指南能让你彻底搞懂 Python 的内存管理机制，写出更高效、更稳定的 Python 代码。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2026-01-13，如有侵权请联系 cloudcommunity@tencent.com 删除

内存管理

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度