Python►experience

Python3的垃圾回收机制

这个大概是经常说的机制。

引用计数机制

Python默认采用的垃圾收集机制是『引用计数法 Reference Counting』，该算法最早由George E. Collins在1960的时候首次提出，直到今天，该算法依然被很多编程语言使用。
『引用计数法』的原理是：每个对象维护一个ob_ref字段，用来记录该对象当前被引用的次数，每当新的引用指向该对象时，它的引用计数ob_ref加1，每当该对象的引用失效时计数ob_ref减1，一旦对象的引用计数为0，该对象立即被回收，对象占用的内存空间将被释放。
它的缺点是需要额外的空间维护引用计数，这个问题是其次的，不过最主要的问题是它不能解决对象的“循环引用”，因此，也有很多语言比如Java并没有采用该算法做来垃圾的收集机制。
接下来我们看个例子。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import sys


class A():
    def __init__(self):
        # init
        print('object id:%s' % str(hex(id(self))))


def f1():
    while True:
        c1 = A()
        del c1


def func(c):
    print('obejct refcount is:', sys.getrefcount(c))  # getrefcount()方法用于返回对象的引用计数


if __name__ == '__main__':
    # create object
    a = A()
    func(a)

    # add reference b
    b = a
    func(a)

    # destruct b
    del b
    func(a)

结果如下

1
2
3
4
object id:0x15a685eaf40
obejct refcount is: 4
obejct refcount is: 5
obejct refcount is: 4

导致引用计数+1的情况

  • 对象被创建，例如a=23
  • 对象被引用，例如b=a
  • 对象被作为参数，传入到一个函数中，例如func(a)
  • 对象作为一个元素，存储在容器中，例如list1=[a,a]

导致引用计数-1的情况

  • 对象的别名被显式销毁，例如del a
  • 对象的别名被赋予新的对象，例如a=24
  • 一个对象离开它的作用域，例如f函数执行完毕时，func函数中的局部变量（全局变量不会）
  • 对象所在的容器被销毁，或从容器中删除对象

内存泄漏样例

1
2
3
4
5
6
7
8
def f2():
    while True:
        c1 = A()
        c2 = A()
        c1.t = c2
        c2.t = c1
        del c1
        del c2

结果如下

1
2
3
4
5
6
7
8
9
10
11
12
13
object id:0x15ad4ca7610
object id:0x15ad4ca65b0
object id:0x15ad4ca6550
object id:0x15ad4ca6370
object id:0x15ad4ca6490
object id:0x15ad4ca6430
object id:0x15ad4ca66a0
object id:0x15ad4ca6940
object id:0x15ad4ca6eb0
object id:0x15ad4ca6b50
object id:0x15ad4ca6610
object id:0x15ad4ca6220
......

创建c1、c2后，计数均为1，执行引用后都变成2，del执行后计数器都降为1，不为0的情况则导致c1、c2不会被销毁。加上while循环，结果就导致无限创建新的对象，新的对象又产生引用，统统无法收回的结果就是内存泄漏。

分代回收

分代回收是一种以空间换时间的操作方式，Python将内存根据对象的存活时间划分为不同的集合，每个集合称为一个代，Python将内存分为了3“代”，分别为0、1、2代，他们对应的是3个链表，它们的垃圾收集频率与对象的存活时间的增大而减小。
新创建的对象都会分配在0代，0代链表的总数达到上限时，Python垃圾收集机制就会被触发，把那些可以被回收的对象回收掉，而那些不会回收的对象就会被移到1代去，依此类推，2代中的对象是存活时间最久的对象，甚至是存活于整个系统的生命周期内。
同时，分代回收是建立在标记清除技术基础之上。分代回收同样作为Python的辅助垃圾收集技术处理那些容器对象。

gc模块垃圾回收

有三种情况会触发gc模块垃圾回收：

  • 调用gc.collect()。
  • 当gc模块的计数器达到阀值的时候。
  • 程序退出的时候。

gc模块提供一个接口给开发者设置垃圾回收的选项。上面说到，采用引用计数的方法管理内存的一个缺陷是循环引用，而gc模块的一个主要功能就是解决循环引用的问题。
下面是一些常用的函数。

函数 作用
gc.enable() 开启自动垃圾收集
gc.disable() 禁用自动垃圾收集
gc.isenabled() 如果启用则返回true
gc.set_debug(flags) 设置gc的debug日志，一般设置为gc.DEBUG_LEAK
gc.collect([generation]) 显式进行垃圾回收，可以输入参数，0代表只检查0代的对象，1代表检查0、1代的对象，2代表检查所有代的对象。如果不传参数，则默认传入2。返回不可达（unreachable objects）对象的数目。
gc.set_threshold(threshold0[, threshold1[, threshold2]) 设置自动执行垃圾回收的频率。
gc.get_count() 获取当前自动执行垃圾回收的计数器，返回返回当前集合计数为元组(count0, count1, count2)。

其他函数可以在官方文档内查看，接下来我们使用看看。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def f3():
    gc.enable()
    gc.set_debug(gc.DEBUG_LEAK)
    while True:
        c1 = A()
        c2 = A()
        c1.t = c2
        c2.t = c1
        del c1
        del c2
        # import gc
        print(gc.garbage)
        print(gc.collect())
        print(gc.garbage)
        time.sleep(10)

结果如下

1
2
3
4
5
6
7
8
9
gc: collectable <A 0x00000222A733AF40>
gc: collectable <A 0x00000222A733AB50>
gc: collectable <dict 0x00000222A72FFC00>
gc: collectable <dict 0x00000222A730F340>
object id:0x222a733af40
object id:0x222a733ab50
[]
4
[<__main__.A object at 0x00000222A733AF40>, <__main__.A object at 0x00000222A733AB50>, {'t': <__main__.A object at 0x00000222A733AB50>}, {'t': <__main__.A object at 0x00000222A733AF40>}]

可以看到gc很快就捕捉到两个A和c1、c2，并判定为可回收的，执行回收之后，garbage列表内多了4个对象。
gc本身采用了分代收集的方法，把对象分为3代，一开始，对象在创建的时候，放在0代中，如果在一次0代的垃圾检查中，该对象存活下来，就会被放到1代中，同理在一次1代的垃圾检查中，该对象存活下来，就会被放到2代中。

用例如下

1
2
3
4
5
6
def f4():
    print(gc.get_count())
    a = A()
    print(gc.get_count())
    del a
    print(gc.get_count())

结果如下

1
2
3
4
(427, 9, 0)
object id:0x13fba46af40
(428, 9, 0)
(427, 9, 0)

427指距离上一次0代垃圾检查，Python分配内存的数目减去释放内存的数目。
9指距离上一次0、1代垃圾检查的次数。
0是指距离上一次0、1、2代垃圾检查的次数。
配合阈值来看，一般默认阈值为(700, 10, 10)，如果当其中任何一个数字达到阈值，则会对应代的执行垃圾回收，即gc.collect([generation])，并将计数器清零。

  • 当计数器从(699, 3, 0)增加到(700, 3, 0)，gc模块就会执行gc.collect(0),并重置计数器为(0, 4, 0)
  • 当计数器从(699, 9, 0)增加到(700, 9, 0)，gc模块就会执行gc.collect(1),并重置计数器为(0, 0, 1)
  • 当计数器从(699, 9 ,9)增加到(700, 9, 9)，gc模块就会执行gc.collect(2),并重置计数器为(0, 0, 0)

标记-清除回收

所谓标记-清除，就是先标记，再清除。标记的是活动对象，清除的是非活动对象。
首先，为了追踪容器对象的引用情况，每个容器对象需要维护两个额外的指针，指针分别指向前后两个容器对象，所有容器对象便组成了一个双向链表，或者，我们也可以将其视为一个有向图。其中，容器对象是有向图的节点，而引用关系是有向图的边。从根对象(root objects)出发，沿着有向边遍历对象，可达的(reachable)对象标记为活动对象，不可达的对象(unreachable objects)就是要被清除的非活动对象。
标记-清除作为Python的辅助垃圾收集技术主要处理的是一些容器对象，比如list、dict、tuple，instance等，因为对于字符串、数值对象是不可能造成循环引用问题。Python使用一个双向链表将这些容器对象组织起来。不过，这种简单粗暴的标记清除算法也有明显的缺点：清除非活动的对象前它必须顺序扫描整个堆内存，哪怕只剩下小部分活动对象也要扫描所有对象。