MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Python对象的生命周期与垃圾回收

2024-08-207.2k 阅读

Python对象的生命周期基础概念

在Python中，对象的生命周期从其被创建开始，到被销毁结束。理解对象的生命周期对于编写高效、稳定的Python程序至关重要。每个对象在内存中都占据一定的空间，当对象不再被使用时，释放这些内存资源就显得尤为重要，这涉及到垃圾回收机制。

Python是一种动态类型语言，在代码运行过程中，解释器会自动管理对象的内存分配和释放。例如，当我们创建一个简单的整数对象：

a = 5

在这行代码执行时，Python解释器会在内存中为整数 5 分配一块空间，并将变量 a 指向这块内存。这里，对象 5 的生命周期就开始了。当变量 a 不再使用（比如超出其作用域），或者 a 被重新赋值指向其他对象时，对象 5 就有可能进入垃圾回收的流程。

Python中的对象有不同的类型，如整数、字符串、列表、字典等，每种类型的对象在生命周期管理上都有一些共性和特性。以字符串对象为例：

s1 = 'hello'
s2 = 'hello'

在上述代码中，s1 和 s2 指向的是同一个字符串对象 'hello'。这是因为Python对于短字符串会进行驻留优化，即相同内容的短字符串在内存中只会存在一份。这种优化机制影响了字符串对象的生命周期管理，使得相同内容的短字符串对象在多个变量引用时，不会重复创建。

作用域与对象生命周期

作用域在Python对象生命周期中扮演着重要角色。Python中有几种不同的作用域，包括局部作用域、全局作用域等。当一个对象在函数内部创建时，它通常具有局部作用域。

def test_scope():
    local_var = 10
    print(local_var)
test_scope()
# 这里如果尝试访问 local_var 会报错，因为 local_var 已经超出了其作用域
# print(local_var)

在函数 test_scope 中创建的 local_var 变量，其作用域仅限于函数内部。当函数执行完毕，local_var 所指向的对象 10 就有可能成为垃圾回收的候选对象。因为在函数外部已经无法再访问到 local_var，也就意味着该对象不再被程序中的有效代码所引用。

而对于全局变量，其作用域是整个模块。例如：

global_var = 20
def access_global():
    print(global_var)
access_global()

global_var 在模块的任何地方都可以被访问，只要模块没有被卸载，global_var 所指向的对象 20 就不会轻易进入垃圾回收流程，因为它始终处于有效的引用状态。

引用计数与对象生命周期

引用计数是Python垃圾回收机制的重要组成部分。Python中的每个对象都有一个引用计数，用于记录当前有多少个变量或其他对象引用了它。当对象的引用计数变为 0 时，该对象就会被立即回收。

我们可以使用 sys.getrefcount() 函数来查看对象的引用计数。但需要注意的是，当我们调用这个函数时，由于函数调用本身会临时增加一次引用计数，所以实际的引用计数需要减 1。

import sys
a = [1, 2, 3]
print(sys.getrefcount(a) - 1)  # 输出 1，因为变量 a 引用了这个列表对象
b = a
print(sys.getrefcount(a) - 1)  # 输出 2，因为变量 b 也引用了这个列表对象
del b
print(sys.getrefcount(a) - 1)  # 输出 1，删除 b 后，只剩下 a 引用这个列表对象
del a
# 此时列表对象的引用计数变为 0，会被立即回收

在上述代码中，我们创建了一个列表对象并赋值给 a，此时列表对象的引用计数为 1。当我们将 a 赋值给 b 时，引用计数增加到 2。通过 del 语句删除 b 后，引用计数减为 1，再删除 a 后，引用计数变为 0，列表对象就会被垃圾回收机制回收。

引用计数的优点是回收速度快，当对象的引用计数变为 0 时，它可以立即被回收，不会像其他一些垃圾回收算法那样需要等待特定的时机。然而，引用计数也有其局限性，它无法解决循环引用的问题。

循环引用与垃圾回收

循环引用是指两个或多个对象之间相互引用，导致它们的引用计数永远不会变为 0，即使这些对象实际上已经不再被程序的其他部分所使用。例如：

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

在上述代码中，a 和 b 两个对象相互引用，形成了循环引用。当我们执行 del a 和 del b 后，虽然 a 和 b 变量不再存在，但 Node 对象之间的相互引用使得它们的引用计数不会变为 0，这些对象就无法通过引用计数机制被回收。

为了解决循环引用问题，Python引入了标记 - 清除（Mark - Sweep）和分代回收（Generational Garbage Collection）机制。

标记 - 清除机制

标记 - 清除机制是Python解决循环引用问题的重要手段。其基本原理是：在垃圾回收开始时，首先暂停程序的运行（这被称为“stop - the - world”），然后从根对象（如全局变量、栈上的变量等）开始遍历，标记所有可以访问到的对象。所有未被标记的对象就是不可达对象，也就是垃圾对象，最后将这些垃圾对象占用的内存空间回收。

具体来说，Python解释器会维护一个双向链表，用于存储所有可能存在循环引用的对象。在标记阶段，从根对象出发，沿着对象的引用关系进行深度优先搜索（DFS）或广度优先搜索（BFS），标记所有可达的对象。例如，假设有如下对象结构：

class A:
    def __init__(self):
        self.b = None
class B:
    def __init__(self):
        self.a = None
a = A()
b = B()
a.b = b
b.a = a

在垃圾回收启动时，从全局变量 a 和 b 出发，通过引用关系可以标记 a、b、a.b（即 b）和 b.a（即 a）这些对象为可达对象。如果在这个过程中没有其他引用指向这些对象，当垃圾回收完成后，这些对象就会被回收。

标记 - 清除机制虽然能够解决循环引用问题，但由于它需要暂停程序运行来进行标记和清除操作，可能会对程序的性能产生一定影响，尤其是在程序中有大量对象需要处理时。

分代回收机制

分代回收机制是基于这样一个事实：新创建的对象很可能很快就不再被使用，而存活时间较长的对象则更有可能继续存活。Python将对象分为不同的代，通常有三代：0代、1代和2代。

新创建的对象被放入0代。当0代中的对象数量达到一定阈值（这个阈值可以通过 gc.set_threshold() 函数进行设置，默认情况下，0代对象数量达到700时触发垃圾回收），就会对0代对象进行垃圾回收。在回收过程中，存活下来的对象会被移到1代。当1代中的对象数量也达到一定阈值（默认是10，即1代对象数量达到10时触发垃圾回收），会对1代对象进行垃圾回收，存活下来的对象再移到2代。2代对象同样有一个阈值（默认也是10），当达到这个阈值时，对2代对象进行垃圾回收。

分代回收机制的优势在于，它更频繁地回收新创建的对象（0代），因为这些对象更有可能成为垃圾。而对于存活时间较长的对象（1代和2代），回收频率相对较低，这样可以减少垃圾回收带来的性能开销。例如：

import gc
# 设置分代回收阈值
gc.set_threshold(700, 10, 10)
# 创建大量对象
for i in range(1000):
    obj = [i]

在上述代码中，大量新创建的列表对象首先进入0代。当对象数量达到700时，会触发0代的垃圾回收。如果有对象存活，它们会被移到1代。随着更多对象的创建和0代垃圾回收的不断进行，1代对象数量可能会达到阈值，进而触发1代的垃圾回收，依此类推。

手动控制垃圾回收

在某些情况下，我们可能需要手动控制垃圾回收。Python提供了 gc 模块来实现这一功能。

可以使用 gc.collect() 函数手动触发垃圾回收。例如：

import gc
# 创建一些对象
a = [1, 2, 3]
b = {'key': 'value'}
# 手动触发垃圾回收
gc.collect()

在上述代码中，调用 gc.collect() 函数后，Python会立即执行垃圾回收操作，回收那些不再被引用的对象。

此外，还可以通过 gc.disable() 函数禁用垃圾回收，通过 gc.enable() 函数重新启用垃圾回收。例如：

import gc
# 禁用垃圾回收
gc.disable()
# 创建对象
c = [4, 5, 6]
# 重新启用垃圾回收
gc.enable()

禁用垃圾回收后，即使对象不再被引用，它们也不会被自动回收。重新启用垃圾回收后，垃圾回收机制会正常工作，回收那些符合条件的垃圾对象。

弱引用与对象生命周期

弱引用是Python中一种特殊的引用类型。与普通引用不同，弱引用不会增加对象的引用计数。这意味着当对象的所有普通引用都消失后，即使存在弱引用，对象也会被垃圾回收。

弱引用在某些场景下非常有用，比如缓存机制。假设我们有一个缓存，其中存储的对象如果长时间不被使用，我们希望它能被自动回收以释放内存，但又想在对象还存活时能够访问到它。这时就可以使用弱引用。

import weakref
class MyClass:
    def __init__(self):
        print('Object created')
    def __del__(self):
        print('Object deleted')
obj = MyClass()
weak_ref = weakref.ref(obj)
del obj
# 此时 MyClass 对象的普通引用已经消失，对象会被垃圾回收
# 通过弱引用尝试访问对象
if weak_ref():
    print('Object still exists:', weak_ref())
else:
    print('Object has been garbage - collected')

在上述代码中，我们创建了一个 MyClass 对象，并创建了对它的弱引用 weak_ref。当删除 obj 后，MyClass 对象的普通引用消失，对象被垃圾回收。通过 weak_ref() 可以尝试获取对象，如果对象已被回收，weak_ref() 会返回 None。

弱引用的存在使得我们在不影响对象正常生命周期的前提下，还能在一定程度上跟踪对象的状态，为程序设计提供了更多的灵活性。

特殊对象的生命周期管理

模块对象

Python中的模块也是对象，每个模块在被导入时会创建一个模块对象。模块对象的生命周期与它所在的进程或解释器会话相关。当模块被首次导入时，Python会创建模块对象，并执行模块中的代码。例如：

# module_example.py
print('Module is being imported')
def module_function():
    print('This is a module function')

在另一个脚本中导入这个模块：

import module_example
module_example.module_function()

模块 module_example 的对象在导入时创建，只要解释器会话没有结束，模块对象就会一直存在。如果模块被重新导入（使用 importlib.reload() 函数），模块中的代码会重新执行，模块对象的状态也会相应更新。

类对象与实例对象

类对象在Python中是一种特殊的对象，它在定义类时被创建。例如：

class MyClass:
    class_variable = 10
    def __init__(self):
        self.instance_variable = 20

这里，MyClass 就是一个类对象。类对象的生命周期从类被定义开始，到解释器会话结束或类对象不再被任何引用指向（在一些动态加载和卸载类的场景下）。

实例对象则是通过类的实例化创建的。如：

obj = MyClass()

obj 就是 MyClass 的一个实例对象。实例对象的生命周期遵循一般对象的生命周期规则，当它不再被任何变量引用时，会进入垃圾回收流程。

函数对象

函数在Python中也是对象，称为函数对象。函数对象在函数定义时被创建。例如：

def my_function():
    print('This is my function')

my_function 就是一个函数对象。函数对象的生命周期与模块对象类似，只要定义它的模块没有被卸载，函数对象就会一直存在。函数对象可以像其他对象一样被传递、存储在数据结构中。例如：

def add(a, b):
    return a + b
func_list = [add]
result = func_list[0](2, 3)
print(result)

在上述代码中，函数对象 add 被存储在列表 func_list 中，并通过列表元素调用函数。

内存泄漏与对象生命周期管理不当

内存泄漏是指程序中已动态分配的内存空间由于某种原因未被释放或无法释放，导致程序运行时占用的内存越来越多，最终可能导致系统内存耗尽。在Python中，虽然垃圾回收机制会自动回收不再使用的对象，但如果对象生命周期管理不当，仍可能出现内存泄漏。

例如，在一个循环中不断创建对象，但没有正确释放对这些对象的引用：

def memory_leak_example():
    data_list = []
    while True:
        new_obj = [1, 2, 3]
        data_list.append(new_obj)
        # 这里没有对 new_obj 的引用释放操作
        # 随着循环进行，data_list 不断增长，占用内存越来越多

在上述代码中，data_list 不断添加新的列表对象，但没有任何机制来减少 data_list 的大小或释放其中对象的引用，这就可能导致内存泄漏。

另外，循环引用如果没有被垃圾回收机制正确处理，也可能导致内存泄漏。如前面提到的相互引用的 Node 对象示例，如果垃圾回收机制出现问题，这些对象就会一直占用内存。

为了避免内存泄漏，我们需要确保在对象不再使用时，及时释放对它们的引用。同时，了解Python的垃圾回收机制，合理使用 gc 模块进行手动控制，也是有效避免内存泄漏的方法。

总结

Python对象的生命周期与垃圾回收机制是Python编程中非常重要的部分。理解对象如何创建、引用计数如何工作、循环引用问题以及垃圾回收机制的原理和实现，对于编写高效、稳定的Python程序至关重要。通过合理管理对象的生命周期，避免内存泄漏，我们可以充分发挥Python语言的优势，开发出性能卓越的应用程序。同时，掌握手动控制垃圾回收和弱引用等高级特性，能让我们在面对复杂场景时，更加灵活地管理内存资源。