Python垃圾回收机制

核心阐述

• 在Python中，主要通过引用计数进行垃圾回收；
• 通过 “标记-清除” 解决容器对象可能产生的循环引用问题；
• 通过 “分代回收” 以空间换时间的方法提高垃圾回收效率。

 

一、引用计数

 

typedef struct_object {
 int ob_refcnt;
 struct_typeobject *ob_type;
} PyObject;

Python中每一个对象的核心就是一个结构体PyObject，它的内部有一个引用计数器（ob_refcnt）。程序在运行的过程中会实时的更新ob_refcnt的值，来反映引用当前对象的名称数量。当某对象的引用计数值为0,那么它的内存就会被立即释放掉。 

可以通过sys包中的getrefcount()来获取一个名称所引用的对象当前的引用计数(注意，这里getrefcount()本身会使得引用计数加一)

以下情况是导致引用计数加一的情况:

• 对象被创建，例如a=2
• 对象被引用，b=a
• 对象被作为参数，传入到一个函数中
• 对象作为一个元素，存储在容器中

下面的情况则会导致引用计数减一：

• 对象别名被显示销毁 del
• 对象别名被赋予新的对象
• 一个对象离开他的作用域
• 对象所在的容器被销毁或者是从容器中删除对象

优点

• 简单易实现：逻辑简单清晰
• 实时性：一旦一个对象的引用计数归零，内存就直接释放了，不用像其他机制等到特定时机。
• 平稳性：将垃圾回收随机分配到运行的阶段，处理回收内存的时间分摊到了平时，正常程序的运行比较平稳。

缺点

• 空间负担：每个对象需要分配单独的空间来统计引用计数，这无形中加大的空间的负担
• 复杂对象释放较慢：比如字典，需要对引用的所有对象循环嵌套调用，从而可能会花费比较长的时间。
• 循环引用问题：这是引用计数的致命伤，引用计数对此是无解的，导致在狭义上并不把引用计数看成是垃圾回收机制的一种，因此必须要使用其它的垃圾回收算法进行补充，如标记-清除法。

lst1 = []
lst2 = []

lst1.append(lst2)
lst2.append(lst1)

del lst1, lst2

初始的时候，lst1和lst2指向的内存的引用计数都为1，但是lst1.append(lst2)，那么lst2指向内存的引用计数变成了2，同理lst2.append(lst1)导致lst1指向内存的引用计数也变成了2。因此当我们del lst1, lst2的时候，引用计数会从2变成1，因此lst1和lst2都不会被回收，但我们是希望回收lst1和lst2的。因此此时我们就说lst1和lst2指向的对象之间发生了循环引用，所以如果只是引用计数的话，那么显然这两者是回收不了的，会造成内存泄漏。

 

二、标记清除

无论何种垃圾回收机制，一般都分为两个阶段：垃圾检测和垃圾回收。

垃圾检测是从所有的已经分配的内存中区别出"可回收"和"不可回收"的内存，所谓垃圾回收，并不是说直接把这块内存的数据清空了，而是将使用权从新交给了操作系统，不会自己霸占了。

Python采用了“标记-清除”(Mark and Sweep)算法，解决容器对象可能产生的循环引用或者自引用问题。要注意的是：只有容器对象才会产生循环引用的情况，比如列表、字典、用户自定义类的对象、元组等。而像数字，字符串这类简单类型不会出现循环引用。作为一种优化策略，对于只包含简单类型的元组也不在标记清除算法的考虑之列。

 

举例说明Python标记-清除的思路

c=[5,6]  # 假设此时c的引用为1
d=[7,8]  # 假设此时d的引用为1
# 循环引用
c.append(d)  # d的引用+1=2
d.append(c)  # c的引用+1=2

del c
del d

前提：

• Python进行标记清除时，CPython维护了两个容器（双端链表）：Object to Scan 和 Unreachable，也有人叫存活容器和死亡容器。
• Python还为每个对象维护了一个ob_refcnt的副本 —— gc_ref，用于进行标记清除，其初始值为ob_refcnt；之所以用副本进行计算，是因为如果用ob_refcnt进行标记清除操作，会破坏每个对象真正的引用计数值。

步骤：

1. 删除后，c和d的引用为1，根据引用计数，还无法回收；
2. GC启动后，会把可能需要被回收的对象都放到Object to Scan链表中，然后将这些对象的内部引用全部拆掉，并将每个对象的引用计数更新到gc_ref中 （如下图）。（本例中，这一步的具体操作过程是：遍历时先找到c，因为c引用了d，那么把d的gc_ref - 1，这样就相当于拆掉了c对d的引用；同样的，遍历到d时，因为d引用了c，c.gc_ref - 1；此时两者的内部引用连接全部拆掉了）
3. （加图）
4. GC会将所有gc_ref为0的对象，移入Unreachable链表中；（在本例子中，即c与d均被移入）
5. 再次遍历还在Object to Scan中的对象（这些对象也被称为根对象 root object），根据原始的引用关系，查看是否有Object to Scan对象引用了Unreachable中的对象，有的话 就把被引的Unreachable对象再移回Object to Scan中。 经过这一步后，依然在Unreachable中的对象就是需要被回收的；标记过程结束。（本例中，没有根对象）
6. GC将Unreachable中的对象释放，完成清除。

补充：

• 可以看到，Python获得根对象是基于引用计数的；在java中，会把“栈、全局变量”之类的东西作为根集合起点。基于引用计数获取根对象，优点在于，针对任意对象集合都可以计算得到，而不需要去扫描栈区和全局区（静态区）。
• 基于上面这点，可以选择把所有对象看做一个集合进行回收，也可以选择划分小集合分别进行回收；划分的粒度越粗，效果越好，但速度越慢。不过Python的做法是分代回收。

 

三、分代回收

经过上面的标记-清除，已经可以保证对垃圾的回收了，但还有一个问题，标记-清除在什么时机执行比较好呢，是对所有对象都同时执行吗？

需要知道的是，标记-清除执行过程中，整个应用程序会被暂停；为了减少程序暂停的时间，Python 通过“分代回收”(Generational Collection)以空间换时间的方法提高垃圾回收效率。

机制：

• Python GC根据对象在内存中存活的时间把它们划分成3个不同的集合：generation 0/1/2；
• 新创建的对象在generation 0中；如果在一轮GC扫描，即 标记-清除 中存活下来，移入generation 1；如果在第二轮GC扫描中存活，则移入generation 2；
• generation 0 -> 2的GC扫描频率逐渐降低，即：存活时间越长的对象，就越不可能是垃圾，则减少对其的回收频率；

GC阈值：

可以通过下面两个函数查看和调整：

gc.get_threshold()  # (threshold0, threshold1, threshold2).
gc.set_threshold(threshold0[, threshold1[, threshold2]])

默认值为(700, 10, 10)，含义是：

• 700：新创建的对象数量 - 从新创建的对象中回收的数量 > 700，就进行一次0代回收;
• 10：当0代回收进行10次后，进行一次1代回收（并同时进行一次0代回收）；
• 10：当1代回收进行10次后，进行一次2代回收（并同时进行一次0代回收和1代回收）；

 

四：垃圾回收的触发

以下三种情况会触发垃圾回收（标记-清除）：

• 调用gc.collect()；
• GC达到阈值时；
• 程序退出是；

 

五、小整数对象池和intern机制

由于整数使用广泛，为了避免为整数频繁销毁、申请内存空间，引入了小整数对象池。[-5,257)是提前定义好的，不会销毁，单个字母也是。

那对于其他整数，或者其他字符串的不可变类型，如果存在重复的多个，例如：

a1="mark"
a2="mark"
a3="mark"
a4="mark"
....
a1000="mark"

如果每次声明都开辟出一段空间，很显然不合理，这个时候python就会使用intern机制，靠引用计数来维护。

• 小整数[-5，257)：共用对象，常驻内存
• 单个字符：共用对象，常驻内存
• 单个单词等不可变类型，默认开启intern机制，共用对象，引用计数为0时销毁。

 

参考：

https://www.zhihu.com/question/32373436/answer/549698608

https://www.cnblogs.com/shengulong/p/10143856.html

https://www.cnblogs.com/traditional/p/13698244.html