聊一聊Python中的“垃圾”回收

作者&＃xff1a;heroyf

www.heroyf.club/2019/10/23/python_gc/

前言

对于python来说&＃xff0c;一切皆为对象&＃xff0c;所有的变量赋值都遵循着对象引用机制。程序在运行的时候&＃xff0c;需要在内存中开辟出一块空间&＃xff0c;用于存放运行时产生的临时变量&＃xff1b;计算完成后&＃xff0c;再将结果输出到永久性存储器中。如果数据量过大&＃xff0c;内存空间管理不善就很容易出现 OOM&＃xff08;out of memory&＃xff09;&＃xff0c;俗称爆内存&＃xff0c;程序可能被操作系统中止。

而对于服务器&＃xff0c;内存管理则显得更为重要&＃xff0c;不然很容易引发内存泄漏- 这里的泄漏&＃xff0c;并不是说你的内存出现了信息安全问题&＃xff0c;被恶意程序利用了&＃xff0c;而是指程序本身没有设计好&＃xff0c;导致程序未能释放已不再使用的内存。- 内存泄漏也不是指你的内存在物理上消失了&＃xff0c;而是意味着代码在分配了某段内存后&＃xff0c;因为设计错误&＃xff0c;失去了对这段内存的控制&＃xff0c;从而造成了内存的浪费。也就是这块内存脱离了gc的控制

计数引用

因为python中一切皆为对象&＃xff0c;你所看到的一切变量&＃xff0c;本质上都是对象的一个指针。

当一个对象不再调用的时候&＃xff0c;也就是当这个对象的引用计数&＃xff08;指针数&＃xff09;为 0 的时候&＃xff0c;说明这个对象永不可达&＃xff0c;自然它也就成为了垃圾&＃xff0c;需要被回收。可以简单的理解为没有任何变量再指向它。

1. import os

2. import psutil

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

5. def show_memory_info(hint):

6. pid &＃61; os.getpid()

7. p &＃61; psutil.Process(pid)

9. info &＃61; p.memory_full_info()

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

11. print( {} memory used: {} MB .format(hint, memory))

14. def func():

15. show_memory_info( initial )

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

17. show_memory_info( after a created )

19. func()

20. show_memory_info( finished )

22. ########## 输出 ##########

23. initial memory used: 47.19140625 MB

24. after a created memory used: 433.91015625 MB

25. finished memory used: 48.109375 MB

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

1. def func():

2. show_memory_info( initial )

3. global a

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

5. show_memory_info( after a created )

7. func()

8. show_memory_info( finished )

10. ########## 输出 ##########

12. initial memory used: 48.88671875 MB

13. after a created memory used: 433.94921875 MB

14. finished memory used: 433.94921875 MB

新的这段代码中&＃xff0c;global a 表示将 a 声明为全局变量。那么&＃xff0c;即使函数返回后&＃xff0c;列表的引用依然存在&＃xff0c;于是对象就不会被垃圾回收掉&＃xff0c;依然占用大量内存。同样&＃xff0c;如果我们把生成的列表返回&＃xff0c;然后在主程序中接收&＃xff0c;那么引用依然存在&＃xff0c;垃圾回收就不会被触发&＃xff0c;大量内存仍然被占用着&＃xff1a;

1. def func():

2. show_memory_info( initial )

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

4. show_memory_info( after a created )

5. return a

7. a &＃61; func()

8. show_memory_info( finished )

10. ########## 输出 ##########

12. initial memory used: 47.96484375 MB

13. after a created memory used: 434.515625 MB

14. finished memory used: 434.515625 MB

那怎么可以看到变量被引用了多少次呢&＃xff1f;通过 sys.getrefcount

1. import sys

3. a &＃61; []

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

6. print(sys.getrefcount(a))

8. def func(a):

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

10. print(sys.getrefcount(a))

12. func(a)

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

15. print(sys.getrefcount(a))

17. ########## 输出 ##########

19. 2

20. 4

21. 2

如果其中涉及函数调用&＃xff0c;会额外增加两次1. 函数栈2. 函数调用

从这里就可以看到python不再需要像C那种的认为的释放内存&＃xff0c;但是python同样给我们提供了手动释放内存的方法 gc.collect()

1. import gc

3. show_memory_info( initial )

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

7. show_memory_info( after a created )

9. del a

10. gc.collect()

12. show_memory_info( finish )

13. print(a)

15. ########## 输出 ##########

17. initial memory used: 48.1015625 MB

18. after a created memory used: 434.3828125 MB

19. finish memory used: 48.33203125 MB

21. ---------------------------------------------------------------------------

22. NameErrorTraceback(most recent call last)

23. in

24. 11

25. 12 show_memory_info( finish )

26. ---> 13print(a)

28. NameError: name a isnotdefined

截止目前&＃xff0c;貌似python的垃圾回收机制非常的简单&＃xff0c;只要对象引用次数为0&＃xff0c;必定为触发gc&＃xff0c;那么引用次数为0是否是触发gc的充要条件呢&＃xff1f;

循环回收

如果有两个对象&＃xff0c;它们互相引用&＃xff0c;并且不再被别的对象所引用&＃xff0c;那么它们应该被垃圾回收吗&＃xff1f;

1. def func():

2. show_memory_info( initial )

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

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

5. show_memory_info( after a, b created )

6. a.append(b)

7. b.append(a)

9. func()

10. show_memory_info( finished )

12. ########## 输出 ##########

14. initial memory used: 47.984375 MB

15. after a, b created memory used: 822.73828125 MB

16. finished memory used: 821.73046875 MB

从结果显而易见&＃xff0c;它们并没有被回收&＃xff0c;但是从程序上来看&＃xff0c;当这个函数结束的时候&＃xff0c;作为局部变量的a&＃xff0c;b就已经从程序意义上不存在了。但是因为它们的互相引用&＃xff0c;导致了它们的引用数都不为0。

这时要如何规避呢1. 从代码逻辑上进行整改&＃xff0c;避免这种循环引用2. 通过人工回收

1. import gc

3. def func():

4. show_memory_info( initial )

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

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

7. show_memory_info( after a, b created )

8. a.append(b)

9. b.append(a)

11. func()

12. gc.collect()

13. show_memory_info( finished )

15. ########## 输出 ##########

17. initial memory used: 49.51171875 MB

18. after a, b created memory used: 824.1328125 MB

19. finished memory used: 49.98046875 MB

python针对循环引用&＃xff0c;有它的自动垃圾回收算法1. 标记清除&＃xff08;mark-sweep&＃xff09;算法2. 分代收集&＃xff08;generational&＃xff09;

标记清除

标记清除的步骤总结为如下步骤1. GC会把所有的『活动对象』打上标记2. 把那些没有标记的对象『非活动对象』进行回收

那么python如何判断何为非活动对象&＃xff1f;

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

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

图中把小黑圈视为全局变量&＃xff0c;也就是把它作为root object&＃xff0c;从小黑圈出发&＃xff0c;对象1可直达&＃xff0c;那么它将被标记&＃xff0c;对象2、3可间接到达也会被标记&＃xff0c;而4和5不可达&＃xff0c;那么1、2、3就是活动对象&＃xff0c;4和5是非活动对象会被GC回收。

分代回收

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

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

所以对于刚刚的问题&＃xff0c;引用计数只是触发gc的一个充分非必要条件&＃xff0c;循环引用同样也会触发。

调试

可以使用 objgraph来调试程序&＃xff0c;因为目前它的官方文档&＃xff0c;还没有细读&＃xff0c;只能把文档放在这供大家参阅啦~

其中两个函数非常有用 1. show_refs() 2. show_backrefs()

总结

1. 垃圾回收是 Python 自带的机制&＃xff0c;用于自动释放不会再用到的内存空间&＃xff1b;

2. 引用计数是其中最简单的实现&＃xff0c;不过切记&＃xff0c;这只是充分非必要条件&＃xff0c;因为循环引用需要通过不可达判定&＃xff0c;来确定是否可以回收&＃xff1b;

3. Python 的自动回收算法包括标记清除和分代回收&＃xff0c;主要针对的是循环引用的垃圾收集&＃xff1b;

4. 调试内存泄漏方面&＃xff0c; objgraph 是很好的可视化分析工具。

推荐阅读

“我靠这9个百度AI项目&＃xff0c;拿到了年薪30万&＃43;的大厂offer”

从词袋到transfomer&＃xff0c;梳理十年Kaggle竞赛&＃xff0c;看自然语言处理的变迁史

Python 海象运算符 (:&＃61;) 的三种用法

GitHub热榜 | AI黑客教程来了&＃xff0c;破解神经网络、攻击GPU

Pandas | 5 种技巧高效利用value-counts