第四章：Python垃圾回收机制深度解析

说到Python的内存管理，很多人第一反应就是「Python有垃圾回收，不用操心内存」。嗯，这话对了一半。我见过太多线上服务因为内存泄漏挂掉，罪魁祸首往往就是对GC机制理解不够深。

今天咱们就把Python的垃圾回收机制掰开揉碎了讲。说白了就三招：引用计数、标记-清除、分代回收。这三招配合起来，才构成了Python的内存管理防线。

4.1 引用计数：Python的默认武器

引用计数是Python最基础的垃圾回收手段。每个Python对象内部都维护着一个计数器，记录着有多少个引用指向它。

我举个例子你就明白了：

import sys

# 创建一个列表对象
a = [1, 2, 3]  
# 此时引用计数为1

b = a  
# 引用计数变为2

print(sys.getrefcount(a))  
# 输出3（getrefcount自己也会增加一次引用）

del b  
# 引用计数降回1

del a  
# 引用计数变为0，对象被回收

什么时候引用计数会增加？说白了就这几种情况：

• 赋值操作：b = a，多了一个引用
• 参数传递：函数调用时传参
• 容器添加：把对象放进列表、字典里
• 属性赋值：obj.attr = some_obj

引用计数减少的情况也类似：del删除、变量超出作用域、从容器中移除等等。

4.2 循环引用的困境

什么是循环引用？看这个例子：

class Node:
    def __init__(self, name):
        self.name = name
        self.parent = None
        self.child = None

# 创建循环引用
a = Node("A")
b = Node("B")
a.child = b
b.parent = a

# 删除外部引用
del a
del b
# 此时a和b的引用计数都是1，永远不会归零！

为什么会这样？a.child指向b，b.parent指向a。就算你把a和b都删了，它们内部还互相指着。引用计数永远到不了0，这两个对象就成了「内存孤儿」。

4.3 标记-清除算法：解决循环引用

Python的解决方案是标记-清除算法。它不依赖引用计数，而是从根对象出发，遍历所有可达对象。

算法分两步走：

1. 标记阶段：从根对象（全局变量、调用栈等）出发，把所有能访问到的对象都打上标记
2. 清除阶段：扫描所有对象，把没标记的统统回收

你想想看，循环引用的两个对象，如果外部已经没有引用指向它们，那从根对象出发就遍历不到。它们自然就成了「不可达对象」，被标记-清除算法收走。

# 标记-清除的简化理解
def mark_sweep(root_objects, all_objects):
    # 标记阶段
    reachable = set()
    def mark(obj):
        if id(obj) in reachable:
            return
        reachable.add(id(obj))
        for ref in get_references(obj):
            mark(ref)
    
    for root in root_objects:
        mark(root)
    
    # 清除阶段
    for obj in all_objects:
        if id(obj) not in reachable:
            free(obj)

4.4 分代回收：性能优化的艺术

标记-清除虽然能解决循环引用，但每次扫描所有对象太慢了。你想想，一个运行了几天几夜的服务，内存里可能有几百万个对象，每次都全量扫描，性能扛不住。

Python的解决方案是分代回收。核心思想很简单：对象存活时间越长，越不可能被回收。

Python把对象分为三代：

代	名称	扫描频率	典型对象
第0代	年轻代	最频繁（默认700次分配触发）	临时变量、局部对象
第1代	中年代	中等（第0代扫描10次触发1次）	存活了一段时间的对象
第2代	老年代	最低（第1代扫描10次触发1次）	长期存活的对象、全局变量

新创建的对象都放在第0代。每次第0代扫描时，存活下来的对象就晋升到第1代。以此类推。老年代的对象很少被扫描，因为能活到老年代的对象，大概率会一直活着。

import gc

# 查看当前各代的对象数量
print(gc.get_count())  
# 输出示例：(596, 2, 1)
# 第0代有596个对象，第1代有2个，第2代有1个

# 手动触发第0代回收
gc.collect(0)

# 查看回收阈值
print(gc.get_threshold())  
# 输出示例：(700, 10, 10)

4.5 实战：如何检测和避免内存泄漏

说了这么多理论，来点实际的。我总结了几条经验：

1. 使用gc模块监控

import gc

# 开启调试信息
gc.set_debug(gc.DEBUG_LEAK)

# 查看无法回收的对象
gc.collect()
for obj in gc.garbage:
    print(type(obj), repr(obj))

2. 使用weakref打破循环引用

import weakref

class Node:
    def __init__(self, name):
        self.name = name
        self.parent = None
        self._child = None
    
    @property
    def child(self):
        return self._child() if self._child else None
    
    @child.setter
    def child(self, node):
        self._child = weakref.ref(node)

# 现在循环引用不会导致内存泄漏了

3. 养成好习惯

• 用with语句管理资源，确保及时释放
• 避免在__del__方法中搞复杂逻辑
• 定期检查gc.get_objects()的数量变化

4.6 小结

Python的垃圾回收机制，说白了就是三招组合拳：引用计数打头阵，标记-清除处理疑难杂症，分代回收优化性能。理解这三招，你就能写出更健壮的Python程序。

记住一点：垃圾回收不是万能的。该手动释放的资源要手动释放，该用weakref的地方别偷懒。我见过太多「Python自动管理内存所以不用操心」的惨案了。

嗯，这一章就到这里。代码写得再漂亮，内存泄漏了也是白搭。希望这些经验对你有帮助。