关于python的垃圾回收机制_深度解析Python垃圾回收机制（超级详细）

我们知道&＃xff0c;目前的计算机都采用的是图灵机架构&＃xff0c;其本质就是用一条无限长的纸带&＃xff0c;对应今天的存储器。随后在工程学的推演中&＃xff0c;逐渐出现了寄存器、易失性存储器&＃xff08;内存&＃xff09;以及永久性存储器&＃xff08;硬盘&＃xff09;等产品。由于不同的存储器&＃xff0c;其速度越快&＃xff0c;单位价格也就越昂贵&＃xff0c;因此&＃xff0c;妥善利用好每一寸告诉存储器的空间&＃xff0c;永远是系统设计的一个核心。

Python 程序在运行时&＃xff0c;需要在内存中开辟出一块空间&＃xff0c;用于存放运行时产生的临时变量&＃xff0c;计算完成后&＃xff0c;再将结果输出到永久性存储器中。但是当数据量过大&＃xff0c;或者内存空间管理不善&＃xff0c;就很容易出现内存溢出的情况&＃xff0c;程序可能会被操作系统终止。

而对于服务器这种用于永不中断的系统来说&＃xff0c;内存管理就显得更为重要了&＃xff0c;不然很容易引发内存泄漏。

这里的内存泄漏是指程序本身没有设计好&＃xff0c;导致程序未能释放已不再使用的内存&＃xff0c;或者直接失去了对某段内存的控制&＃xff0c;造成了内存的浪费。

那么&＃xff0c;对于不会再用到的内存空间&＃xff0c;Python 是通过什么机制来管理的呢&＃xff1f;其实在前面章节已大致接触过&＃xff0c;就是引用计数机制。

Python引用计数机制

在学习 Python 的整个过程中&＃xff0c;我们一直在强调&＃xff0c;Python 中一切皆对象&＃xff0c;也就是说&＃xff0c;在 Python 中你用到的一切变量&＃xff0c;本质上都是类对象。

那么&＃xff0c;如何知道一个对象永远都不能再使用了呢&＃xff1f;很简单&＃xff0c;就是当这个对象的引用计数值为 0 时&＃xff0c;说明这个对象永不再用&＃xff0c;自然它就变成了垃圾&＃xff0c;需要被回收。

举个例子&＃xff1a;

import os

import psutil

# 显示当前 python 程序占用的内存大小

def show_memory_info(hint):

pid &＃61; os.getpid()

p &＃61; psutil.Process(pid)

info &＃61; p.memory_full_info()

memory &＃61; info.uss / 1024. / 1024

print(&＃39;{} memory used: {} MB&＃39;.format(hint, memory))

def func():

show_memory_info(&＃39;initial&＃39;)

a &＃61; [i for i in range(10000000)]

show_memory_info(&＃39;after a created&＃39;)

func()

show_memory_info(&＃39;finished&＃39;)

输出结果为&＃xff1a;

initial memory used: 47.19140625 MB

after a created memory used: 433.91015625 MB

finished memory used: 48.109375 MB

注意&＃xff0c;运行此程序之前&＃xff0c;需安装 psutil 模块&＃xff08;获取系统信息的模块&＃xff09;&＃xff0c;可使用 pip 命令直接安装&＃xff0c;执行命令为 $pip install psutil&＃xff0c;如果遇到 Permission denied 安装失败&＃xff0c;请加上 sudo 重试。

可以看到&＃xff0c;当调用函数 func() 且列表 a 被创建之后&＃xff0c;内存占用迅速增加到了 433 MB&＃xff0c;而在函数调用结束后&＃xff0c;内存则返回正常。这是因为&＃xff0c;函数内部声明的列表 a 是局部变量&＃xff0c;在函数返回后&＃xff0c;局部变量的引用会注销掉&＃xff0c;此时列表 a 所指代对象的引用计数为 0&＃xff0c;Python 便会执行垃圾回收&＃xff0c;因此之前占用的大量内存就又回来了。

明白了这个原理后&＃xff0c;稍微修改上面的代码&＃xff0c;如下所示&＃xff1a;

def func():

show_memory_info(&＃39;initial&＃39;)

global a

a &＃61; [i for i in range(10000000)]

show_memory_info(&＃39;after a created&＃39;)

func()

show_memory_info(&＃39;finished&＃39;)

输出结果为&＃xff1a;

initial memory used: 48.88671875 MB

after a created memory used: 433.94921875 MB

finished memory used: 433.94921875 MB

上面这段代码中&＃xff0c;global a 表示将 a 声明为全局变量&＃xff0c;则即使函数返回后&＃xff0c;列表的引用依然存在&＃xff0c;于是 a 对象就不会被当做垃圾回收掉&＃xff0c;依然占用大量内存。

同样&＃xff0c;如果把生成的列表返回&＃xff0c;然后在主程序中接收&＃xff0c;那么引用依然存在&＃xff0c;垃圾回收也不会被触发&＃xff0c;大量内存仍然被占用着&＃xff1a;

def func():

show_memory_info(&＃39;initial&＃39;)

a &＃61; [i for i in derange(10000000)]

show_memory_info(&＃39;after a created&＃39;)

return a

a &＃61; func()

show_memory_info(&＃39;finished&＃39;)

输出结果为&＃xff1a;

initial memory used: 47.96484375 MB

after a created memory used: 434.515625 MB

finished memory used: 434.515625 MB

以上最常见的几种情况&＃xff0c;下面由表及里&＃xff0c;深入看一下 Python 内部的引用计数机制。先来分析一段代码&＃xff1a;

import sys

a &＃61; []

# 两次引用&＃xff0c;一次来自 a&＃xff0c;一次来自 getrefcount

print(sys.getrefcount(a))

def func(a):

# 四次引用&＃xff0c;a&＃xff0c;python 的函数调用栈&＃xff0c;函数参数&＃xff0c;和 getrefcount

print(sys.getrefcount(a))

func(a)

# 两次引用&＃xff0c;一次来自 a&＃xff0c;一次来自 getrefcount&＃xff0c;函数 func 调用已经不存在

print(sys.getrefcount(a))

输出结果为&＃xff1a;

2

4

2

注意&＃xff0c;sys.getrefcount() 函数用于查看一个变量的引用次数&＃xff0c;不过别忘了&＃xff0c;getrefcount 本身也会引入一次计数。

另一个要注意的是&＃xff0c;在函数调用发生的时候&＃xff0c;会产生额外的两次引用&＃xff0c;一次来自函数栈&＃xff0c;另一个是函数参数。

import sys

a &＃61; []

print(sys.getrefcount(a)) # 两次

b &＃61; a

print(sys.getrefcount(a)) # 三次

c &＃61; b

d &＃61; b

e &＃61; c

f &＃61; e

g &＃61; d

print(sys.getrefcount(a)) # 八次

输出结果为&＃xff1a;

2

3

8

分析一下这段代码&＃xff0c;a、b、c、d、e、f、g 这些变量全部指代的是同一个对象&＃xff0c;而 sys.getrefcount() 函数并不是统计一个指针&＃xff0c;而是要统计一个对象被引用的次数&＃xff0c;所以最后一共会有 8 次引用。

理解引用这个概念后&＃xff0c;引用释放是一种非常自然和清晰的思想。相比 C 语言中需要使用 free 去手动释放内存&＃xff0c;Python 的垃圾回收在这里可以说是省心省力了。

不过&＃xff0c;有读者还是会好奇&＃xff0c;如果想手动释放内存&＃xff0c;应该怎么做呢&＃xff1f;方法同样很简单&＃xff0c;只需要先调用 del a 来删除一个对象&＃xff0c;然后强制调用 gc.collect() 即可手动启动垃圾回收。例如&＃xff1a;

import gc

show_memory_info(&＃39;initial&＃39;)

a &＃61; [i for i in range(10000000)]

show_memory_info(&＃39;after a created&＃39;)

del a

gc.collect()

show_memory_info(&＃39;finish&＃39;)

print(a)

输出结果为&＃xff1a;

initial memory used: 48.1015625 MB

after a created memory used: 434.3828125 MB

finish memory used: 48.33203125 MB

NameError Traceback (most recent call last)

in

11

12 show_memory_info(&＃39;finish&＃39;)

---> 13 print(a)

NameError: name &＃39;a&＃39; is not defined

是不是觉得垃圾回收非常简单呢&＃xff1f;这里再问大家一个问题&＃xff1a;引用次数为 0 是垃圾回收启动的充要条件吗&＃xff1f;还有没有其他可能性呢&＃xff1f;

其实&＃xff0c;引用计数是其中最简单的实现&＃xff0c;引用计数并非充要条件&＃xff0c;它只能算作充分非必要条件&＃xff0c;至于其他的可能性&＃xff0c;下面所讲的循环引用正是其中一种。

循环引用

首先思考一个问题&＃xff0c;如果有两个对象&＃xff0c;之间互相引用&＃xff0c;且不再被别的对象所引用&＃xff0c;那么它们应该被垃圾回收吗&＃xff1f;

举个例子&＃xff1a;

def func():

show_memory_info(&＃39;initial&＃39;)

a &＃61; [i for i in range(10000000)]

b &＃61; [i for i in range(10000000)]

show_memory_info(&＃39;after a, b created&＃39;)

a.append(b)

b.append(a)

func()

show_memory_info(&＃39;finished&＃39;)

输出结果为&＃xff1a;

initial memory used: 47.984375 MB

after a, b created memory used: 822.73828125 MB

finished memory used: 821.73046875 MB

程序中&＃xff0c;a 和 b 互相引用&＃xff0c;并且作为局部变量在函数 func 调用结束后&＃xff0c;a 和 b 这两个指针从程序意义上已经不存在&＃xff0c;但从输出结果中看到&＃xff0c;依然有内存占用&＃xff0c;这是为什么呢&＃xff1f;因为互相引用导致它们的引用数都不为 0。

试想一下&＃xff0c;如果这段代码出现在生产环境中&＃xff0c;哪怕 a 和 b 一开始占用的空间不是很大&＃xff0c;但经过长时间运行后&＃xff0c;Python 所占用的内存一定会变得越来越大&＃xff0c;最终撑爆服务器&＃xff0c;后果不堪设想。

有读者可能会说&＃xff0c;互相引用还是很容易被发现的呀&＃xff0c;问题不大。可是&＃xff0c;更隐蔽的情况是出现一个引用环&＃xff0c;在工程代码比较复杂的情况下&＃xff0c;引用环真不一定能被轻易发现。那么应该怎么做呢&＃xff1f;

事实上&＃xff0c;Python 本身能够处理这种情况&＃xff0c;前面刚刚讲过&＃xff0c;可以显式调用 gc.collect() 来启动垃圾回收&＃xff0c;例如&＃xff1a;

import gc

def func():

show_memory_info(&＃39;initial&＃39;)

a &＃61; [i for i in range(10000000)]

b &＃61; [i for i in range(10000000)]

show_memory_info(&＃39;after a, b created&＃39;)

a.append(b)

b.append(a)

func()

gc.collect()

show_memory_info(&＃39;finished&＃39;)

输出结果为&＃xff1a;

initial memory used: 49.51171875 MB

after a, b created memory used: 824.1328125 MB

finished memory used: 49.98046875 MB

事实上&＃xff0c;Python 使用标记清除&＃xff08;mark-sweep&＃xff09;算法和分代收集&＃xff08;generational&＃xff09;&＃xff0c;来启用针对循环引用的自动垃圾回收。

先来看标记清除算法。我们先用图论来理解不可达的概念。对于一个有向图&＃xff0c;如果从一个节点出发进行遍历&＃xff0c;并标记其经过的所有节点&＃xff1b;那么&＃xff0c;在遍历结束后&＃xff0c;所有没有被标记的节点&＃xff0c;我们就称之为不可达节点。显而易见&＃xff0c;这些节点的存在是没有任何意义的&＃xff0c;自然的&＃xff0c;我们就需要对它们进行垃圾回收。

当然&＃xff0c;每次都遍历全图&＃xff0c;对于 Python 而言是一种巨大的性能浪费。所以&＃xff0c;在 Python 的垃圾回收实现中&＃xff0c;标记清除算法使用双向链表维护了一个数据结构&＃xff0c;并且只考虑容器类的对象&＃xff08;只有容器类对象才有可能产生循环引用&＃xff09;。

而分代收集算法&＃xff0c;则是将 Python 中的所有对象分为三代。刚刚创立的对象是第 0 代&＃xff1b;经过一次垃圾回收后&＃xff0c;依然存在的对象&＃xff0c;便会依次从上一代挪到下一代。而每一代启动自动垃圾回收的阈值&＃xff0c;则是可以单独指定的。当垃圾回收器中新增对象减去删除对象达到相应的阈值时&＃xff0c;就会对这一代对象启动垃圾回收。

事实上&＃xff0c;分代收集基于的思想是&＃xff0c;新生的对象更有可能被垃圾回收&＃xff0c;而存活更久的对象也有更高的概率继续存活。因此&＃xff0c;通过这种做法&＃xff0c;可以节约不少计算量&＃xff0c;从而提高 Python 的性能。

由于篇幅有限&＃xff0c;这里不再对标记清除算法和分代收集算法的具体实现所详细介绍&＃xff0c;有兴趣的读者可自行百度搜索。