Python 垃圾回收

gledfish

已于 2023-03-21 18:32:17 修改

阅读量117

点赞数

分类专栏： Python 文章标签： python 开发语言

于 2023-03-21 16:46:18 首次发布

原文链接：https://www.pythontutorial.net/advanced-python/python-garbage-collection/

版权

Python 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

这篇文章翻译自https://www.pythontutorial.net/advanced-python/python-garbage-collection/

Python 垃圾回收

摘要：在这篇教程，你将学习 Python 的垃圾回收是如何工作的，以及如何在程序中与垃圾回收器交互。

垃圾回收简介

在C/C++中，你要完全负责管理程序的内存。然而，在 Python 中，你不需要自己管理内存，因为 Python 会自动为你做这件事。

在引用教程中，你已经学会了Python内存管理器对对象的引用进行跟踪。一旦该对象的引用计数为零，内存管理器就会销毁该对象并收回内存。

然而，引用计数并不是一直都能正常工作。例如，当你有一个对象引用自己或两个对象相互引用时。这就产生了一种叫做循环引用的东西。

当 Python 内存管理器不能删除具有循环引用的对象时，会导致内存泄漏。

这就是为什么垃圾收集器会发挥作用来修复循环引用。

Python允许你通过内置的 gc 模块与垃圾收集器交互。

与Python垃圾收集器交互

在下面这个例子中，我们首先在类A和类B的两个实例之间创建一个循环引用，然后使用垃圾收集器来销毁循环引用中的对象。

首先，导入 gc 和 ctypes 模块，并定义了两个函数用于计算引用和检查对象是否存在于内存中。


imort gc
import ctypes

def ref_count(addreess):
    return ctypes.c_long.from_address(address).value

def object_exists(object_id):
    for object in gc.get_objects():
        if(id(object) == object_id):
            return True
    
    return False

在这段代码中， ref_count() 返回一个由其内存地址指定的对象的引用计数。而 object_exists() 函数传入一个对象，如果在内存中存在一个对象，则返回 True 。

然后，创建类 A 和类B，两个类相互引用。

class A:
    def __init__(self):
        self.b = B(self)
        print(f'A: {hex(id(self))}, B: {hex(id(self.b))}')


class B:
    def __init__(self, a):
        self.a = a
        print(f'B: {hex(id(self))}, A: {hex(id(self.a))}')

第三，通过调用 disable() 函数禁用垃圾收集器。

gc.disable()

第四，创建一个新的A类实例，同时自动创建一个新的B类实例。

a = A()

输出

B: 0x20fccd148e0, A: 0x20fccd75c40
A: 0x20fccd75c40, B: 0x20fccd148e0

第五，定义两个变量来保存A和B的实例的内存地址。当变量 a 引用另一个对象时，这些变量将跟踪A和B的实例的内存地址。

a_id = id(a)
b_id = id(a.b)

第六，显示A和B的实例的引用计数。

print(ref_count(a_id)) # 2
print(ref_count(b_id)) # 1

A的实例有两个引用，即变量 a 和B的实例。B的实例有一个引用，即A的实例。

第七，检查A和B的实例是否都在内存中。

print(object_exists(str(a_id)))  # True
print(object_exists(str(b_id)))  # True

两个实例都在。

第八，设置 a 变量为 None 。

a = None

第九，获得A和B的实例的引用计数。

print(ref_count(a_id)) # 1
print(ref_count(b_id)) # 1

现在，A 和 B 的实例的引用数都是1。

第十，检查实例是否存在。

print(object_exists(a_id))  # True
print(object_exists(b_id))  # True

这两个地址仍然如期存在。

第十一，启动垃圾收集器。

gc.collect()

当垃圾收集器运行时，它可以检测到循环引用，销毁对象，并回收内存。

第十二，检查A和B的实例是否存在。

print(object_exists(a_id))  # False
print(object_exists(b_id))  # False

由于垃圾收集器的处理，这两个实例都不存在了。

第十三，得到A和B的实例的参考计数。

print(ref_count(a_id))  # 0
print(ref_count(b_id))  # 0

把这些整合在一起

import gc
import ctypes


def ref_count(address):
    return ctypes.c_long.from_address(address).value


def object_exists(object_id):
    for object in gc.get_objects():
        if id(object) == object_id:
            return True

    return False


class A:
    def __init__(self):
        self.b = B(self)
        print(f'A: {hex(id(self))}, B: {hex(id(self.b))}')


class B:
    def __init__(self, a):
        self.a = a
        print(f'B: {hex(id(self))}, A: {hex(id(self.a))}')


# disable the garbage collector
gc.disable()

a = A()

a_id = id(a)
b_id = id(a.b)

print(ref_count(a_id))  # 2
print(ref_count(b_id))  # 1

print(object_exists(a_id))  # True
print(object_exists(b_id))  # True


a = None
print(ref_count(a_id))  # 1
print(ref_count(b_id))  # 1

print(object_exists(a_id))  # True
print(object_exists(b_id))  # True

# run the garbage collector
gc.collect()

# check if object exists
print(object_exists(a_id))  # False
print(object_exists(b_id))  # False

# reference count
print(ref_count(a_id))  # 0
print(ref_count(b_id))  # 0