Python的内存管理机制

Python作为一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言，与大多数编程语言不同，Python中的变量无需事先申明，变量无需指定类型，程序员无需关心内存管理，Python解释器给你自动回收。开发人员不用过多的关心内存管理机制，这一切全部由python内存管理器承担了复杂的内存管理工作。

内存不外乎创建和销毁两部分，本文将围绕python的内存池和垃圾回收两部分进行分析。

当创建大量消耗小内存的对象时，频繁调用 new/malloc 会导致大量的内存碎片，致使效率降低。内存池的作用就是预先在内存中申请一定数量的，大小相等的内存块留作备用，当有新的内存需求时，就先从内存池中分配内存给这个需求，不够之后再申请新的内存。这样做最显著的优势就是能够减少内存碎片，提升效率。

2.内存池是如何工作的（how）

首先，我们看一张 CPython （Python 解释器）的内存架构图：

• Python 的对象管理主要位于 Level+1~Level+3 层。

• Level+3 层：对于Python内置的对象（比如int,dict等）都有独立的私有内存池，对象之间的内存池不共享，即int释放的内存，不会被分配给float使用。

• Level+2 层：当申请的内存大小小于256KB时，内存分配主要由 Python 对象分配器（Python’s object allocator）实施。

• Level+1 层：当申请的内存大小大于256KB时，由Python原生的内存分配器进行分配，本质上是调用C标准库中的malloc/realloc等函数。

Python的垃圾回收机制采用引用计数机制为主，标记-清除和分代回收机制为辅的策略。其中，标记-清除机制用来解决计数引用带来的循环引用而无法释放内存的问题，分代回收机制是为提升垃圾回收的效率。

1. >>> a=[1,2]
2. >>> import sys
3. >>> sys.getrefcount(a) ## 获取对象a的引用次数
4. 2
5. >>> b=a
6. >>> sys.getrefcount(a)
7. 3
8. >>> del b ## 删除b的引用
9. >>> sys.getrefcount(a)
10. 2
11. >>> c=list()
12. >>> c.append(a) ## 加入到容器中
13. >>> sys.getrefcount(a)
14. 3
15. >>> del c ## 删除容器，引用-1
16. >>> sys.getrefcount(a)
17. 2
18. >>> b=a
19. >>> sys.getrefcount(a)
20. 3
21. >>> a=[3,4] ## 重新赋值
22. >>> sys.getrefcount(a)
23. 2

• 引用计数增加的情况：

1. 一个对象被分配给一个新的名字（例如：a=[1,2]）

2. 将其放入一个容器中（如列表、元组或字典）（例如：c.append(a)）

• 引用计数减少的情况：

1. 使用del语句对对象别名显式的销毁(例如：del b)

2. 对象所在的容器被销毁或从容器中删除对象（例如：del c ）

3. 引用超出作用域或被重新赋值（例如：a=[3,4]）

标记-清除

标记-清除用来解决引用计数机制产生的循环引用，进而导致内存泄漏的问题 。循环引用只有在容器对象才会产生，比如字典，元组，列表等。

顾名思义，该机制在进行垃圾回收时分成了两步，分别是：

• 标记阶段，遍历所有的对象，如果是可达的（reachable），也就是还有对象引用它，那么就标记该对象为可达。

• 清除阶段，再次遍历对象，如果发现某个对象没有标记为可达（即为Unreachable），则就将其回收。

1. >>> a=[1,2]
2. >>> b=[3,4]
3. >>> sys.getrefcount(a)
4. 2
5. >>> sys.getrefcount(b)
6. 2
7. >>> a.append(b)
8. >>> sys.getrefcount(b)
9. 3
10. >>> b.append(a)
11. >>> sys.getrefcount(a)
12. 3
13. >>> del a
14. >>> del b

• a引用b,b引用a,此时两个对象各自被引用了2次（去除getrefcout()的临时引用）

• 执行del之后，对象a,b的引用次数都-1，此时各自的引用计数器都为1，陷入循环引用

• 标记：找到其中的一端a,因为它有一个对b的引用，则将b的引用计数-1

• 标记：再沿着引用到b,b有一个a的引用,将a的引用计数-1，此时对象a和b的引用次数全部为0，被标记为不可达（Unreachable）

清除: 被标记为不可达的对象就是真正需要被释放的对象。

分代回收

1. >>> import gc
2. >>> gc.get_threshold() ## 分代回收机制的参数阈值设置
3. (700, 10, 10)

• 700=新分配的对象数量-释放的对象数量，第0代gc扫描被触发。

• 第一个10：第0代gc扫描发生10次，则第1代的gc扫描被触发。

• 第二个10：第1代的gc扫描发生10次，则第2代的gc扫描被触发。

在标记-清除中，如果对象c也引用a,执行del操作后，会发生什么？对象a,b,c的引用关系如下图所示：

1. >>> a=[1,2]
2. >>> b=[3,4]
3. >>> c=a
4. >>> a.append(b)
5. >>> b.append(a)

• ref_count表示引用计数
• 对象a,b,c全部为reachable

执行del之后，引用关系如下图所示：

1. >>> del a
2. >>> del b

• a,b,c的ref_count减1

执行gc扫描

• 标记: a引用b,将b的refcount减1到0，b引用a,将a的refcount减1到1，将b放在unreachable下 。
• 再循环:因为a是可达的，所以会递归地将从a节点出发可以达到的所有节点标记为reachable下，即为： 
• 清除:unreachable下没有可清除的对象，因此a,b,c对象不会被清除。

本文链接：http://so.lmcjl.com/news/21317/