编辑“︁Python 垃圾回收”︁

= Python垃圾回收 =

'''Python垃圾回收'''（Garbage Collection，简称GC）是Python内存管理机制的核心部分，它负责自动回收不再使用的内存空间，以避免内存泄漏并提高程序效率。Python主要使用'''引用计数'''和'''分代回收'''两种机制来实现垃圾回收。

== 概述 ==

在Python中，对象的内存管理是自动进行的。当一个对象不再被引用时，垃圾回收机制会将其占用的内存释放。Python的垃圾回收机制包括：

1. '''引用计数'''：每个对象都有一个计数器，记录有多少变量引用它。当引用计数降为0时，对象会被立即回收。
2. '''分代回收'''（Generational GC）：Python将对象分为三代（Generation 0、1、2），根据对象的存活时间进行不同频率的回收。
3. '''循环引用检测'''：引用计数无法处理循环引用的情况，因此Python使用分代回收机制来检测并回收循环引用的对象。

== 引用计数 ==

引用计数是Python最基本的垃圾回收机制。每当一个对象被引用时，其引用计数加1；当引用失效时，计数减1。当引用计数为0时，对象会被立即销毁。

=== 示例 ===
<syntaxhighlight lang="python">
# 示例1：引用计数
a = [1, 2, 3]  # 列表对象的引用计数为1（变量a引用它）
b = a          # 引用计数增加到2（变量b也引用它）
del a          # 引用计数减1（变量a不再引用它，计数为1）
b = None       # 引用计数减1（变量b不再引用它，计数为0，对象被回收）
</syntaxhighlight>

=== 引用计数的优缺点 ===
* '''优点'''：
  * 实时性高，对象一旦没有引用就立即回收。
  * 不需要额外的CPU资源追踪对象。
* '''缺点'''：
  * 无法处理循环引用（如两个对象互相引用，但外部无引用）。
  * 频繁更新引用计数可能影响性能。

== 分代回收 ==

为了解决循环引用问题，Python引入了分代垃圾回收机制。该机制基于“弱代假说”（Weak Generational Hypothesis）：
* 大多数对象的生命周期很短。
* 存活时间越长的对象，越可能继续存活。

Python将对象分为三代：
* '''Generation 0'''：新创建的对象。
* '''Generation 1'''：经历过一次GC后仍存活的对象。
* '''Generation 2'''：经历过多次GC后仍存活的对象。

GC会优先检查Generation 0，如果对象存活则晋升到下一代。检查频率：Generation 0 > Generation 1 > Generation 2。

=== 示例 ===
<syntaxhighlight lang="python">
# 示例2：循环引用
import gc

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

# 创建循环引用
node1 = Node(1)
node2 = Node(2)
node1.next = node2  # node1引用node2
node2.next = node1  # node2引用node1

# 手动触发垃圾回收
gc.collect()  # 分代回收机制会检测并回收循环引用的对象
</syntaxhighlight>

=== 分代回收的触发条件 ===
* 当分配对象的数量减去释放对象的数量超过阈值时（默认700）。
* 手动调用<code>gc.collect()</code>。

== 循环引用检测 ==

循环引用是指两个或多个对象互相引用，导致它们的引用计数永远不会降为0。Python的分代回收机制通过追踪对象之间的引用关系来检测并回收这类对象。

=== 示例 ===
<syntaxhighlight lang="python">
# 示例3：循环引用导致的内存泄漏（未启用GC时）
import gc

class MyClass:
    def __init__(self):
        self.ref = None

# 创建循环引用
obj1 = MyClass()
obj2 = MyClass()
obj1.ref = obj2
obj2.ref = obj1

# 删除外部引用
obj1 = None
obj2 = None

# 手动触发GC
gc.collect()  # 回收循环引用的对象
</syntaxhighlight>

== 实际应用场景 ==

=== 场景1：缓存管理 ===
在实现缓存时，垃圾回收机制可以帮助自动清理不再使用的缓存对象，避免内存泄漏。

<syntaxhighlight lang="python">
# 示例4：缓存清理
import weakref

class Cache:
    def __init__(self):
        self._cache = weakref.WeakValueDictionary()  # 使用弱引用字典

    def get(self, key):
        return self._cache.get(key)

    def set(self, key, value):
        self._cache[key] = value

# 使用缓存
cache = Cache()
data = [1, 2, 3]
cache.set("data_key", data)

# 当data不再被引用时，缓存自动清理
data = None
</syntaxhighlight>

=== 场景2：资源释放 ===
垃圾回收机制可以确保文件、数据库连接等资源被正确释放。

<syntaxhighlight lang="python">
# 示例5：资源释放
class FileHandler:
    def __init__(self, filename):
        self.file = open(filename, 'r')

    def __del__(self):
        self.file.close()  # 对象被回收时自动关闭文件

handler = FileHandler("example.txt")
handler = None  # 触发__del__方法
</syntaxhighlight>

== 垃圾回收的优化 ==

* 避免频繁创建和销毁对象（如循环中创建大量临时对象）。
* 使用弱引用（<code>weakref</code>模块）减少循环引用。
* 手动调用<code>gc.collect()</code>在关键点释放内存。

== 总结 ==

Python的垃圾回收机制通过引用计数和分代回收实现了高效的内存管理。理解这些机制有助于编写更高效、更健壮的代码，尤其是在处理循环引用和大规模数据时。

== 参见 ==
* [[Python内存管理]]
* [[Python性能优化]]

[[Category:编程语言]]
[[Category:Python]]
[[Category:Python 内存管理]]