大师兄的Python源码学习笔记(五十三）: Python的内存管理机制(八）
大师兄的Python源码学习笔记(五十五）: Python的内存管理机制(十）
五、Python中的垃圾收集
2. 分代的垃圾收集
- 无论何种语言开发，何种类型，何种规模的程序，都存在一个相似点：
- 大部分的内存块的生命周期比较短，而另外一部分会比较长，甚至从程序开始持续到结束。
- 这个比例通常在80%到98%之间。
- 这点对于垃圾收集技术有重要意义：
- 像标记—清除这样的垃圾收集所带来的额外操作，实际上与系统中总的内存块数相关。
- 所以当内存块数越少时，垃圾收集所带来的的额外操作越少，效率更高。
- 基于这点，可以采用一种空间换时间的策略：
- 将系统中的所有内存块根据其存货时间划分为不同的集合，每一个集合称为一代。
- 垃圾收集的频率随着代的存活时间的增大而减小，也就是说活得越长的对象，就越不可能是垃圾，应该更少去收集。
- 存活的时间用垃圾收集动作的次数来衡量，如果一个对象经过的垃圾收集次数越多，其存活时间越长。
- Python中的分代垃圾收集机制共分三代：
- 所谓一代就是一个链表，所属同一代就是在同一个链表中。
- 所以三代就是维护三个链表。
Include/internal/mem.h
struct gc_generation {
PyGC_Head head;
int threshold; /* collection threshold */
int count; /* count of allocations or collections of younger
generations */
};
Modules/gcmodule.c
#define GEN_HEAD(n) (&_PyRuntime.gc.generations[n].head)
void
_PyGC_Initialize(struct _gc_runtime_state *state)
{
state->enabled = 1; /* automatic collection enabled? */
#define _GEN_HEAD(n) (&state->generations[n].head)
struct gc_generation generations[NUM_GENERATIONS] = {
/* PyGC_Head, threshold, count */
{{{_GEN_HEAD(0), _GEN_HEAD(0), 0}}, 700, 0},
{{{_GEN_HEAD(1), _GEN_HEAD(1), 0}}, 10, 0},
{{{_GEN_HEAD(2), _GEN_HEAD(2), 0}}, 10, 0},
};
for (int i = 0; i < NUM_GENERATIONS; i++) {
state->generations[i] = generations[i];
};
state->generation0 = GEN_HEAD(0);
struct gc_generation permanent_generation = {
{{&state->permanent_generation.head, &state->permanent_generation.head, 0}}, 0, 0
};
state->permanent_generation = permanent_generation;
}
- 在_PyObject_GC_TRACK中，可以看到变量_PyGC_generation0，这是一个指针，它指向的正是第0代的内存块集合：
Include/objimpl.h
/* Tell the GC to track this object. NB: While the object is tracked the
* collector it must be safe to call the ob_traverse method. */
#define _PyObject_GC_TRACK(o) do { \
PyGC_Head *g = _Py_AS_GC(o); \
if (_PyGCHead_REFS(g) != _PyGC_REFS_UNTRACKED) \
Py_FatalError("GC object already tracked"); \
_PyGCHead_SET_REFS(g, _PyGC_REFS_REACHABLE); \
g->gc.gc_next = _PyGC_generation0; \
g->gc.gc_prev = _PyGC_generation0->gc.gc_prev; \
g->gc.gc_prev->gc.gc_next = g; \
_PyGC_generation0->gc.gc_prev = g; \
} while (0);
- 对于每一个gc_generation，其中的count记录了当前这条可收集对象链表中一共有多少个可收集对象。
- 在_PyObject_GC_Alloc中，我们可以看到在分配内存后，都会进行
count++动作，将第0代内存链表中所维护的内存块数量加1：
Modules/gcmodule.c
static PyObject *
_PyObject_GC_Alloc(int use_calloc, size_t basicsize)
{
PyObject *op;
PyGC_Head *g;
... ...
_PyRuntime.gc.generations[0].count++; /* number of allocated GC objects */
... ...
}
- 这意味着所有新创建的对象实际上都会被加入到第0代可收集对象链表中。
- 在gc_generation中，threshold记录了该条可收集对象链表中最多可容纳多少个可收集对象，从源码中可以看到这个数字是700。
- 也就是说一旦第0代内存链表的数量超过700，则会立即出发垃圾回收机制。
Modules/gcmodule.c
static Py_ssize_t
collect_generations(void)
{
int i;
Py_ssize_t n = 0;
/* Find the oldest generation (highest numbered) where the count
* exceeds the threshold. Objects in the that generation and
* generations younger than it will be collected. */
for (i = NUM_GENERATIONS-1; i >= 0; i--) {
if (_PyRuntime.gc.generations[i].count > _PyRuntime.gc.generations[i].threshold) {
/* Avoid quadratic performance degradation in number
of tracked objects. See comments at the beginning
of this file, and issue #4074.
*/
if (i == NUM_GENERATIONS - 1
&& _PyRuntime.gc.long_lived_pending < _PyRuntime.gc.long_lived_total / 4)
continue;
n = collect_with_callback(i);
break;
}
}
return n;
}
- 虽然是由第0代内存链表的越界出发了垃圾收集，但Python会借机对所有满足
count值越界的代内存链表进行垃圾收集。
