Python基础之C语言源码分析垃圾回收机制
两个重要的结构体
#define PyObject_HEAD PyObject ob_base; #define PyObject_VAR_HEAD PyVarObject ob_base; // 宏定义，包含 上一个、下一个，用于构造双向链表用。(放到refchain链表中时，要用到) #define _PyObject_HEAD_EXTRA \ struct _object *_ob_next; \ struct _object *_ob_prev; typedef struct _object { _PyObject_HEAD_EXTRA // 用于构造双向链表 Py_ssize_t ob_refcnt; // 引用计数器 struct _typeobject *ob_type; // 数据类型 } PyObject; typedef struct { PyObject ob_base; // PyObject对象 Py_ssize_t ob_size; /* Number of items in variable part，即：元素个数 */ } PyVarObject;
这两个结构体PyObject和PyVarObject是基石，他们保存这其他数据类型公共部分，例如：每个类型的对象在创建时都有PyObject中的那4部分数据；list/set/tuple等由多个元素组成对象创建时都有PyVarObject中的那5部分数据。
常见类型结构体
平时我们在创建一个对象时，本质上就是实例化一个相关类型的结构体，在内部保存值和引用计数器等。
- float类型
typedef struct {
PyObject_HEAD
double ob_fval;
} PyFloatObject;
- int类型
struct _longobject { PyObject_VAR_HEAD digit ob_digit[1]; }; /* Long (arbitrary precision) integer object interface */ typedef struct _longobject PyLongObject; /* Revealed in longintrepr.h */
- str类型
typedef struct {
PyObject_HEAD
Py_ssize_t length; /* Number of code points in the string */
Py_hash_t hash; /* Hash value; -1 if not set */
struct {
unsigned int interned:2;
/* Character size:
- PyUnicode_WCHAR_KIND (0):
* character type = wchar_t (16 or 32 bits, depending on the
platform)
- PyUnicode_1BYTE_KIND (1):
* character type = Py_UCS1 (8 bits, unsigned)
* all characters are in the range U+0000-U+00FF (latin1)
* if ascii is set, all characters are in the range U+0000-U+007F
(ASCII), otherwise at least one character is in the range
U+0080-U+00FF
- PyUnicode_2BYTE_KIND (2):
* character type = Py_UCS2 (16 bits, unsigned)
* all characters are in the range U+0000-U+FFFF (BMP)
* at least one character is in the range U+0100-U+FFFF
- PyUnicode_4BYTE_KIND (4):
* character type = Py_UCS4 (32 bits, unsigned)
* all characters are in the range U+0000-U+10FFFF
* at least one character is in the range U+10000-U+10FFFF
*/
unsigned int kind:3;
unsigned int compact:1;
unsigned int ascii:1;
unsigned int ready:1;
unsigned int :24;
} state;
wchar_t *wstr; /* wchar_t representation (null-terminated) */
} PyASCIIObject;
typedef struct {
PyASCIIObject _base;
Py_ssize_t utf8_length; /* Number of bytes in utf8, excluding the
* terminating \0. */
char *utf8; /* UTF-8 representation (null-terminated) */
Py_ssize_t wstr_length; /* Number of code points in wstr, possible
* surrogates count as two code points. */
} PyCompactUnicodeObject;
typedef struct {
PyCompactUnicodeObject _base;
union {
void *any;
Py_UCS1 *latin1;
Py_UCS2 *ucs2;
Py_UCS4 *ucs4;
} data; /* Canonical, smallest-form Unicode buffer */
} PyUnicodeObject;
- list类型
typedef struct {
PyObject_VAR_HEAD
PyObject **ob_item;
Py_ssize_t allocated;
} PyListObject;
- tuple类型
typedef struct {
PyObject_VAR_HEAD
PyObject *ob_item[1];
} PyTupleObject;
- dict类型
typedef struct {
PyObject_HEAD
Py_ssize_t ma_used;
PyDictKeysObject *ma_keys;
PyObject **ma_values;
} PyDictObject;
通过常见结构体可以基本了解到本质上每个对象内部会存储的数据。
扩展：在结构体部分你应该发现了str类型比较繁琐，那是因为python字符串在处理时需要考虑到编码的问题，在内部规定（见源码结构体）：
-
字符串只包含ascii，则每个字符用1个字节表示，即：latin1
-
字符串包含中文等，则每个字符用2个字节表示，即：ucs2
-
字符串包含emoji等，则每个字符用4个字节表示，即：ucs4
Float类型
创建
val = 3.14
类似于这样创建一个float对象时，会执行C源码中的如下代码：
// Objects/floatobject.c
// 用于缓存float对象的链表
static PyFloatObject *free_list = NULL;
static int numfree = 0;
PyObject *
PyFloat_FromDouble(double fval)
{
// 如果free_list中有可用对象，则从free_list链表拿出来一个；否则为对象重新开辟内存。
PyFloatObject *op = free_list;
if (op != NULL) {
free_list = (PyFloatObject *) Py_TYPE(op);
numfree--;
} else {
// 根据float类型的大小，为float对象新开辟内存。
op = (PyFloatObject*) PyObject_MALLOC(sizeof(PyFloatObject));
if (!op)
return PyErr_NoMemory();
}
// 对float对象进行初始化，例如：引用计数器初始化为1、添加到refchain链表等。
/* Inline PyObject_New */
(void)PyObject_INIT(op, &PyFloat_Type);
// 对float对象赋值。即：op->ob_fval = 3.14
op->ob_fval = fval;
return (PyObject *) op;
}
// Include/objimpl.h
#define PyObject_INIT(op, typeobj) \
( Py_TYPE(op) = (typeobj), _Py_NewReference((PyObject *)(op)), (op) )
// Objects/object.c
// 维护了所有对象的一个环状双向链表
static PyObject refchain = {&refchain, &refchain};
void
_Py_AddToAllObjects(PyObject *op, int force)
{
if (force || op->_ob_prev == NULL) {
op->_ob_next = refchain._ob_next;
op->_ob_prev = &refchain;
refchain._ob_next->_ob_prev = op;
refchain._ob_next = op;
}
}
void
_Py_NewReference(PyObject *op)
{
_Py_INC_REFTOTAL;
// 引用计数器初始化为1。
op->ob_refcnt = 1;
// 对象添加到双向链表refchain中。
_Py_AddToAllObjects(op, 1);
_Py_INC_TPALLOCS(op);
}
引用
val = 3.14 data = val
在项目中如果出现这种引用关系时，会将原对象的引用计数器+1。
C源码执行流程如下：
// Include/object.h
static inline void _Py_INCREF(PyObject *op)
{
_Py_INC_REFTOTAL;
// 对象的引用计数器 + 1
op->ob_refcnt++;
}
#define Py_INCREF(op) _Py_INCREF(_PyObject_CAST(op))
销毁
val = 3.14
del val
在项目中如果出现这种删除的语句，则内部会将引用计数器-1，如果引用计数器减为0，则进行缓存或垃圾回收。
C源码执行流程如下：
// Include/object.h
static inline void _Py_DECREF(const char *filename, int lineno,
PyObject *op)
{
(void)filename; /* may be unused, shut up -Wunused-parameter */
(void)lineno; /* may be unused, shut up -Wunused-parameter */
_Py_DEC_REFTOTAL;
// 引用计数器-1，如果引用计数器为0，则执行 _Py_Dealloc去缓存或垃圾回收。
if (--op->ob_refcnt != 0) {
#ifdef Py_REF_DEBUG
if (op->ob_refcnt < 0) {
_Py_NegativeRefcount(filename, lineno, op);
}
#endif
}
else {
_Py_Dealloc(op);
}
}
#define Py_DECREF(op) _Py_DECREF(__FILE__, __LINE__, _PyObject_CAST(op))
// Objects/object.c
void
_Py_Dealloc(PyObject *op)
{
// 找到float类型的 tp_dealloc 函数
destructor dealloc = Py_TYPE(op)->tp_dealloc;
// 在refchain双向链表中摘除此对象。
_Py_ForgetReference(op);
// 执行float类型的 tp_dealloc 函数，去进行缓存或垃圾回收。
(*dealloc)(op);
}
void
_Py_ForgetReference(PyObject *op)
{
...
// 在refchain链表中移除此对象
op->_ob_next->_ob_prev = op->_ob_prev;
op->_ob_prev->_ob_next = op->_ob_next;
op->_ob_next = op->_ob_prev = NULL;
_Py_INC_TPFREES(op);
}
// Objects/floatobject.c
#define PyFloat_MAXFREELIST 100
static int numfree = 0;
static PyFloatObject *free_list = NULL;
// float类型中函数的对应关系
PyTypeObject PyFloat_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"float",
sizeof(PyFloatObject),
0,
// tp_dealloc表示执行float_dealloc方法
(destructor)float_dealloc, /* tp_dealloc */
0, /* tp_print */
...
};
static void
float_dealloc(PyFloatObject *op)
{
// 检测是否是float类型
if (PyFloat_CheckExact(op)) {
// 检测free_list中缓存的个数是否已满，如果已满，则直接将对象销毁。
if (numfree >= PyFloat_MAXFREELIST) {
// 销毁
PyObject_FREE(op);
return;
}
// 将对象加入到free_list链表中
numfree++;
Py_TYPE(op) = (struct _typeobject *)free_list;
free_list = op;
}
else
Py_TYPE(op)->tp_free((PyObject *)op);
}
Int类型
创建
age = 19
当在python中创建一个整型数据时，底层会触发他的如下源码:
PyObject *
PyLong_FromLong(long ival)
{
PyLongObject *v;
...
// 优先去小数据池中检查，如果在范围内则直接获取不再重新开辟内存。（ -5 <= value < 257）
CHECK_SMALL_INT(ival);
...
// 非小数字池中的值，重新开辟内存并初始化
v = _PyLong_New(ndigits);
if (v != NULL) {
digit *p = v->ob_digit;
Py_SIZE(v) = ndigits*sign;
t = abs_ival;
...
}
return (PyObject *)v;
}
#define NSMALLNEGINTS 5
#define NSMALLPOSINTS 257
#define CHECK_SMALL_INT(ival) \
do if (-NSMALLNEGINTS <= ival && ival < NSMALLPOSINTS) { \
return get_small_int((sdigit)ival); \
} while(0)
static PyObject *
get_small_int(sdigit ival)
{
PyObject *v;
v = (PyObject *)&small_ints[ival + NSMALLNEGINTS];
// 引用计数器 + 1
Py_INCREF(v);
...
return v;
}
PyLongObject *
_PyLong_New(Py_ssize_t size)
{
// 创建PyLongObject的指针变量
PyLongObject *result;
...
// 根据长度进行开辟内存
result = PyObject_MALLOC(offsetof(PyLongObject, ob_digit) +
size*sizeof(digit));
...
// 对内存中的数据进行初始化并添加到refchain链表中。
return (PyLongObject*)PyObject_INIT_VAR(result, &PyLong_Type, size);
}
// Include/objimpl.h
#define PyObject_NewVar(type, typeobj, n) \
( (type *) _PyObject_NewVar((typeobj), (n)) )
static inline PyVarObject*
_PyObject_INIT_VAR(PyVarObject *op, PyTypeObject *typeobj, Py_ssize_t size)
{
assert(op != NULL);
Py_SIZE(op) = size;
// 对象初始化
PyObject_INIT((PyObject *)op, typeobj);
return op;
}
#define PyObject_INIT(op, typeobj) \
_PyObject_INIT(_PyObject_CAST(op), (typeobj))
static inline PyObject*
_PyObject_INIT(PyObject *op, PyTypeObject *typeobj)
{
assert(op != NULL);
Py_TYPE(op) = typeobj;
if (PyType_GetFlags(typeobj) & Py_TPFLAGS_HEAPTYPE) {
Py_INCREF(typeobj);
}
// 对象初始化，并把对象加入到refchain链表。
_Py_NewReference(op);
return op;
}
// Objects/object.c
// 维护了所有对象的一个环状双向链表
static PyObject refchain = {&refchain, &refchain};
void
_Py_AddToAllObjects(PyObject *op, int force)
{
if (force || op->_ob_prev == NULL) {
op->_ob_next = refchain._ob_next;
op->_ob_prev = &refchain;
refchain._ob_next->_ob_prev = op;
refchain._ob_next = op;
}
}
void
_Py_NewReference(PyObject *op)
{
_Py_INC_REFTOTAL;
// 引用计数器初始化为1。
op->ob_refcnt = 1;
// 对象添加到双向链表refchain中。
_Py_AddToAllObjects(op, 1);
_Py_INC_TPALLOCS(op);
}
引用
value = 69
data = value
类似于出现这种引用关系时，内部其实就是将对象的引用计数器+1，源码同float类型引用。
销毁
value = 699
del value
在项目中如果出现这种删除的语句，则内部会将引用计数器-1，如果引用计数器减为0，则直接进行垃圾回收。（int类型是基于小数据池而不是free_list做的缓存，所以不会在销毁时缓存数据）。
C源码执行流程如下：
// Include/object.h
static inline void _Py_DECREF(const char *filename, int lineno,
PyObject *op)
{
(void)filename; /* may be unused, shut up -Wunused-parameter */
(void)lineno; /* may be unused, shut up -Wunused-parameter */
_Py_DEC_REFTOTAL;
// 引用计数器-1，如果引用计数器为0，则执行 _Py_Dealloc去垃圾回收。
if (--op->ob_refcnt != 0) {
#ifdef Py_REF_DEBUG
if (op->ob_refcnt < 0) {
_Py_NegativeRefcount(filename, lineno, op);
}
#endif
}
else {
_Py_Dealloc(op);
}
}
#define Py_DECREF(op) _Py_DECREF(__FILE__, __LINE__, _PyObject_CAST(op))
// Objects/object.c
void
_Py_Dealloc(PyObject *op)
{
// 找到int类型的 tp_dealloc 函数（int类中没有定义tp_dealloc函数，需要去父级PyBaseObject_Type中找tp_dealloc函数）
// 此处体现所有的类型都继承object
destructor dealloc = Py_TYPE(op)->tp_dealloc;
// 在refchain双向链表中摘除此对象。
_Py_ForgetReference(op);
// 执行int类型的 tp_dealloc 函数，去进行垃圾回收。
(*dealloc)(op);
}
void
_Py_ForgetReference(PyObject *op)
{
...
// 在refchain链表中移除此对象
op->_ob_next->_ob_prev = op->_ob_prev;
op->_ob_prev->_ob_next = op->_ob_next;
op->_ob_next = op->_ob_prev = NULL;
_Py_INC_TPFREES(op);
}
// Objects/longobjet.c
PyTypeObject PyLong_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"int", /* tp_name */
offsetof(PyLongObject, ob_digit), /* tp_basicsize */
sizeof(digit), /* tp_itemsize */
0, /* tp_dealloc */
...
PyObject_Del, /* tp_free */
};
Objects/typeobject.c
PyTypeObject PyBaseObject_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"object", /* tp_name */
sizeof(PyObject), /* tp_basicsize */
0, /* tp_itemsize */
object_dealloc, /* tp_dealloc */
...
PyObject_Del, /* tp_free */
};
static void
object_dealloc(PyObject *self)
{
// 调用int类型的 tp_free，即：PyObject_Del去销毁对象。
Py_TYPE(self)->tp_free(self);
}
Str类型
创建
name = "featherwit"
当在python中创建一个字符串数据时，底层会触发他的如下源码:
Objects/unicodeobject.c
PyObject *
PyUnicode_DecodeUTF8Stateful(const char *s,Py_ssize_t size,const char *errors,Py_ssize_t *consumed)
{
return unicode_decode_utf8(s, size, _Py_ERROR_UNKNOWN, errors, consumed);
}
static PyObject *
unicode_decode_utf8(const char *s, Py_ssize_t size,_Py_error_handler error_handler, const char *errors,Py_ssize_t *consumed);
{
...
// 如果字符串长度为1，并且是ascii字符，直接去缓存链表 *unicode_latin1[256] 中获取。
if (size == 1 && (unsigned char)s[0] < 128) {
if (consumed)
*consumed = 1;
return get_latin1_char((unsigned char)s[0]);
}
// 对传入的utf-8的字节进行处理，并选择合适的方式转换成unicode字符串。（latin2/ucs2/ucs4）。
...
return _PyUnicodeWriter_Finish(&writer);
}
static PyObject*
get_latin1_char(unsigned char ch)
{
PyObject *unicode = unicode_latin1[ch];
if (!unicode) {
unicode = PyUnicode_New(1, ch);
if (!unicode)
return NULL;
PyUnicode_1BYTE_DATA(unicode)[0] = ch;
assert(_PyUnicode_CheckConsistency(unicode, 1));
unicode_latin1[ch] = unicode;
}
Py_INCREF(unicode);
return unicode;
}
PyObject *
_PyUnicodeWriter_Finish(_PyUnicodeWriter *writer)
{
PyObject *str;
// 写入值到str
str = writer->buffer;
writer->buffer = NULL;
if (writer->readonly) {
assert(PyUnicode_GET_LENGTH(str) == writer->pos);
return str;
}
if (PyUnicode_GET_LENGTH(str) != writer->pos) {
PyObject *str2;
// 创建对象
str2 = resize_compact(str, writer->pos);
if (str2 == NULL) {
Py_DECREF(str);
return NULL;
}
str = str2;
}
assert(_PyUnicode_CheckConsistency(str, 1));
return unicode_result_ready(str);
}
static PyObject*
resize_compact(PyObject *unicode, Py_ssize_t length)
{
...
// 开辟内存
new_unicode = (PyObject *)PyObject_REALLOC(unicode, new_size);
if (new_unicode == NULL) {
_Py_NewReference(unicode);
PyErr_NoMemory();
return NULL;
}
unicode = new_unicode;
// 把对象加入到refchain链表
_Py_NewReference(unicode);
...
return unicode;
}
在字符串中除了会执行上述代码之外，还会执行以下代码实现内部的驻留机制。为了更好的理解，你可以认为驻留机制：将字符串保存到一个名为 interned 的字典中，以后再使用时 直接去字典中获取不再需要创建。
实际在源码中每次都会创建新的字符串，只不过在内部检测是否已驻留到interned中，如果在则使用interned内部的原来的字符串，把新创建的字符串当做垃圾去回收。
Objects/unicodeobject.c
void
PyUnicode_InternInPlace(PyObject **p)
{
PyObject *s = *p;
PyObject *t;
#ifdef Py_DEBUG
assert(s != NULL);
assert(_PyUnicode_CHECK(s));
#else
if (s == NULL || !PyUnicode_Check(s))
return;
#endif
/* If it's a subclass, we don't really know what putting
it in the interned dict might do. */
if (!PyUnicode_CheckExact(s))
return;
if (PyUnicode_CHECK_INTERNED(s))
return;
if (interned == NULL) {
interned = PyDict_New();
if (interned == NULL) {
PyErr_Clear(); /* Don't leave an exception */
return;
}
}
Py_ALLOW_RECURSION
// 将新字符串驻留到interned字典中，不存在则驻留，已存在则不再重复驻留。
t = PyDict_SetDefault(interned, s, s);
Py_END_ALLOW_RECURSION
if (t == NULL) {
PyErr_Clear();
return;
}
// 存在，使用已驻留的字符串 并 将引用计数器+1
if (t != s) {
Py_INCREF(t);
Py_SETREF(*p, t); // 处理临时对象
return;
}
/* The two references in interned are not counted by refcnt.
The deallocator will take care of this */
Py_REFCNT(s) -= 2; // 让临时对象可被回收。
_PyUnicode_STATE(s).interned = SSTATE_INTERNED_MORTAL;
}
引用
同上，引用计数器 + 1 .
销毁
val = "featherwit" del val
在项目中如果出现这种删除的语句，则内部会将引用计数器-1，如果引用计数器减为0，则进行缓存或垃圾回收。
// Include/object.h
static inline void _Py_DECREF(const char *filename, int lineno,
PyObject *op)
{
(void)filename; /* may be unused, shut up -Wunused-parameter */
(void)lineno; /* may be unused, shut up -Wunused-parameter */
_Py_DEC_REFTOTAL;
// 引用计数器-1，如果引用计数器为0，则执行 _Py_Dealloc去缓存或垃圾回收。
if (--op->ob_refcnt != 0) {
#ifdef Py_REF_DEBUG
if (op->ob_refcnt < 0) {
_Py_NegativeRefcount(filename, lineno, op);
}
#endif
}
else {
_Py_Dealloc(op);
}
}
#define Py_DECREF(op) _Py_DECREF(__FILE__, __LINE__, _PyObject_CAST(op))
// Objects/object.c
void
_Py_Dealloc(PyObject *op)
{
// 找到str类型的 tp_dealloc 函数
destructor dealloc = Py_TYPE(op)->tp_dealloc;
// 在refchain双向链表中摘除此对象。
_Py_ForgetReference(op);
// 执行float类型的 tp_dealloc 函数，去进行缓存或垃圾回收。
(*dealloc)(op);
}
void
_Py_ForgetReference(PyObject *op)
{
...
// 在refchain链表中移除此对象
op->_ob_next->_ob_prev = op->_ob_prev;
op->_ob_prev->_ob_next = op->_ob_next;
op->_ob_next = op->_ob_prev = NULL;
_Py_INC_TPFREES(op);
}
// Objects/unicodeobject.c
PyTypeObject PyUnicode_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"str", /* tp_name */
sizeof(PyUnicodeObject), /* tp_basicsize */
0, /* tp_itemsize */
/* Slots */
(destructor)unicode_dealloc, /* tp_dealloc */
...
PyObject_Del, /* tp_free */
};
static void
unicode_dealloc(PyObject *unicode)
{
switch (PyUnicode_CHECK_INTERNED(unicode)) {
case SSTATE_NOT_INTERNED:
break;
case SSTATE_INTERNED_MORTAL:
/* revive dead object temporarily for DelItem */
Py_REFCNT(unicode) = 3;
// 在interned中删除驻留的字符串
if (PyDict_DelItem(interned, unicode) != 0)
Py_FatalError(
"deletion of interned string failed");
break;
case SSTATE_INTERNED_IMMORTAL:
Py_FatalError("Immortal interned string died.");
/* fall through */
default:
Py_FatalError("Inconsistent interned string state.");
}
if (_PyUnicode_HAS_WSTR_MEMORY(unicode))
PyObject_DEL(_PyUnicode_WSTR(unicode));
if (_PyUnicode_HAS_UTF8_MEMORY(unicode))
PyObject_DEL(_PyUnicode_UTF8(unicode));
if (!PyUnicode_IS_COMPACT(unicode) && _PyUnicode_DATA_ANY(unicode))
PyObject_DEL(_PyUnicode_DATA_ANY(unicode));
// 内存中销毁对象
Py_TYPE(unicode)->tp_free(unicode);
}
List类型
创建
v = [11, 22, 33]
当创建一个列表时候，内部的C源码会执行如下：
// Objects/listobject.c
#define PyList_MAXFREELIST 80
// free_list用于对list对象进行缓存，最多可缓存80个对象
static PyListObject *free_list[PyList_MAXFREELIST];
// free_list中可用的对象
static int numfree = 0;
PyObject *
PyList_New(Py_ssize_t size)
{
PyListObject *op;
if (size < 0) {
PyErr_BadInternalCall();
return NULL;
}
if (numfree) {
// 如果free_list中有缓存的对象，则直接从free_list中获取一个对象来使用。
numfree--;
op = free_list[numfree];
_Py_NewReference((PyObject *)op);
} else {
// 缓存中没有，则需要 开辟内存 & 初始化对象
op = PyObject_GC_New(PyListObject, &PyList_Type);
if (op == NULL)
return NULL;
}
if (size <= 0)
op->ob_item = NULL;
else {
op->ob_item = (PyObject **) PyMem_Calloc(size, sizeof(PyObject *));
if (op->ob_item == NULL) {
Py_DECREF(op);
return PyErr_NoMemory();
}
}
Py_SIZE(op) = size;
op->allocated = size;
// 把对象加入到分代回收的三代中的0代链表中。
_PyObject_GC_TRACK(op);
return (PyObject *) op;
}
static inline void _PyObject_GC_TRACK_impl(const char *filename, int lineno,
PyObject *op)
{
_PyObject_ASSERT_FROM(op, !_PyObject_GC_IS_TRACKED(op),
"object already tracked by the garbage collector",
filename, lineno, "_PyObject_GC_TRACK");
PyGC_Head *gc = _Py_AS_GC(op);
_PyObject_ASSERT_FROM(op,
(gc->_gc_prev & _PyGC_PREV_MASK_COLLECTING) == 0,
"object is in generation which is garbage collected",
filename, lineno, "_PyObject_GC_TRACK");
// 把对象加入到链表中，链表尾部还是gc.generation0。
PyGC_Head *last = (PyGC_Head*)(_PyRuntime.gc.generation0->_gc_prev);
_PyGCHead_SET_NEXT(last, gc);
_PyGCHead_SET_PREV(gc, last);
_PyGCHead_SET_NEXT(gc, _PyRuntime.gc.generation0);
_PyRuntime.gc.generation0->_gc_prev = (uintptr_t)gc;
}
#define _PyObject_GC_TRACK(op) \
_PyObject_GC_TRACK_impl(__FILE__, __LINE__, _PyObject_CAST(op))
Include/objimpl.h
#define PyObject_GC_New(type, typeobj) \
( (type *) _PyObject_GC_New(typeobj) )
//Modules/gcmodule.c
PyObject *
_PyObject_GC_New(PyTypeObject *tp)
{
// 创建对象
PyObject *op = _PyObject_GC_Malloc(_PyObject_SIZE(tp));
if (op != NULL)
// 初始化对象并把对象加入到refchain链表中。
op = PyObject_INIT(op, tp);
return op;
}
PyObject *
_PyObject_GC_Malloc(size_t basicsize)
{
return _PyObject_GC_Alloc(0, basicsize);
}
static PyObject *
_PyObject_GC_Alloc(int use_calloc, size_t basicsize)
{
// 包含分代回收的三代链表
struct _gc_runtime_state *state = &_PyRuntime.gc;
PyObject *op;
PyGC_Head *g;
size_t size;
if (basicsize > PY_SSIZE_T_MAX - sizeof(PyGC_Head))
return PyErr_NoMemory();
size = sizeof(PyGC_Head) + basicsize;
// 创建 gc head
if (use_calloc)
g = (PyGC_Head *)PyObject_Calloc(1, size);
else
g = (PyGC_Head *)PyObject_Malloc(size);
if (g == NULL)
return PyErr_NoMemory();
assert(((uintptr_t)g & 3) == 0); // g must be aligned 4bytes boundary
g->_gc_next = 0;
g->_gc_prev = 0;
// 分代回收的0代数量+1
state->generations[0].count++; /* number of allocated GC objects */
// 如果0代超出自己的阈值，进行垃圾分代回收。
if (state->generations[0].count > state->generations[0].threshold && state->enabled && state->generations[0].threshold && !state->collecting && !PyErr_Occurred())
{
// 正在收集
state->collecting = 1;
// 去进行垃圾回收收集
collect_generations(state);
// 结束收集
state->collecting = 0;
}
op = FROM_GC(g);
return op;
}
/* Get the object given the GC head */
#define FROM_GC(g) ((PyObject *)(((PyGC_Head *)g)+1))
static Py_ssize_t
collect_generations(struct _gc_runtime_state *state)
{
Py_ssize_t n = 0;
// 倒序循环三代，按照：2、1、0顺序
for (int i = NUM_GENERATIONS-1; i >= 0; i--) {
if (state->generations[i].count > state->generations[i].threshold) {
if (i == NUM_GENERATIONS - 1 && state->long_lived_pending < state->long_lived_total / 4)
continue;
// 去进行回收，回收当前代之前的所有代。
n = collect_with_callback(state, i);
break;
}
}
return n;
}
static Py_ssize_t
collect_with_callback(struct _gc_runtime_state *state, int generation)
{
...
// 回收，0、1、2代（通过引用传参获取 已回收的和未回收的链表）
result = collect(state, generation, &collected, &uncollectable, 0);
...
return result;
}
/* This is the main function. Read this to understand how the collection process works. */
static Py_ssize_t
collect(struct _gc_runtime_state *state, int generation,
Py_ssize_t *n_collected, Py_ssize_t *n_uncollectable, int nofail)
{
int i;
Py_ssize_t m = 0; /* # objects collected */
Py_ssize_t n = 0; /* # unreachable objects that couldn't be collected */
PyGC_Head *young; /* the generation we are examining */
PyGC_Head *old; /* next older generation */
PyGC_Head unreachable; /* non-problematic unreachable trash */
PyGC_Head finalizers; /* objects with, & reachable from, __del__ */
PyGC_Head *gc;
_PyTime_t t1 = 0; /* initialize to prevent a compiler warning */
/* update collection and allocation counters */
// generation分别会是 0 1 2
// 让当前执行收集的代的更高级的代的count加1 ？例如：0带时，让1代的count+1
// 因为当前带扫描一次，则更高级代count+1，当前带扫描到10次时，更高级的带要扫描一次。
if (generation+1 < NUM_GENERATIONS)
state->generations[generation+1].count += 1;
// 比当前代低的代的count设置为0，因为当前带扫描时候会携带年轻带一起扫描，本次扫描之后对象都会升级到高级别的带，年轻代则为0
for (i = 0; i <= generation; i++)
state->generations[i].count = 0;
// 总结：比当前扫描的代高的带count+1，自己和比自己低的代count设置为0.
// 将比自己代低的所有代，搞到一个链表中
// #define GEN_HEAD(state, n) (&(state)->generations[n].head)
for (i = 0; i < generation; i++) {
gc_list_merge(GEN_HEAD(state, i), GEN_HEAD(state, generation));
}
// 获取当前代的head（链表头）
// #define GEN_HEAD(state, n) (&(state)->generations[n].head)
young = GEN_HEAD(state, generation);
// 比当前代老的head（链表头），如果是0、1、2中的2代时，则两个值相等。
if (generation < NUM_GENERATIONS-1)
//0、1代
old = GEN_HEAD(state, generation+1);
else
//2代
old = young;
// 循环当前代（包含比自己年轻的代的链表）重的每个元素，将引用计数器拷贝到gc_refs中。
// 拷贝出来的用于以后做计数器的计算，不回去更改原来的引用计数器的值。
update_refs(young); // gc_prev is used for gc_refs
// 处理循环引用，把循环引用的位置值为0.
subtract_refs(young);
// 将链表中所有引用计数器为0的，移动到unreachable链表（不可达链表）。
// 循环young链表中的每个元素，并根据拷贝的引用计数器gc_refs进行判断，如果为0则放入不可达链表；
gc_list_init(&unreachable);
move_unreachable(young, &unreachable); // gc_prev is pointer again
validate_list(young, 0);
untrack_tuples(young);
/* Move reachable objects to next generation. */
// 将可达对象加入到下一代。
if (young != old) {
// 如果是0、1代，则升级到下一代。
if (generation == NUM_GENERATIONS - 2) {
// 如果是1代，则更新
state->long_lived_pending += gc_list_size(young);
}
// 把young链表拼接到old链表中。
gc_list_merge(young, old);
}
else {
/* We only untrack dicts in full collections, to avoid quadratic
dict build-up. See issue #14775. */
// 如果是2代，则更新long_lived_total和long_lived_pending
untrack_dicts(young);
state->long_lived_pending = 0;
state->long_lived_total = gc_list_size(young);
}
// 循环所有不可达的元素，把具有 __del__ 方法对象放到finalizers链表中。
// 调用__del__之后，再会进行让他们在销毁。
gc_list_init(&finalizers);
// NEXT_MASK_UNREACHABLE is cleared here.
// After move_legacy_finalizers(), unreachable is normal list.
move_legacy_finalizers(&unreachable, &finalizers);
/* finalizers contains the unreachable objects with a legacy finalizer;
* unreachable objects reachable *from* those are also uncollectable,
* and we move those into the finalizers list too.
*/
move_legacy_finalizer_reachable(&finalizers);
validate_list(&finalizers, 0);
validate_list(&unreachable, PREV_MASK_COLLECTING);
...
/* Clear weakrefs and invoke callbacks as necessary. */
// 循环所有的不可达元素，处理所有弱引用到unreachable，如果弱引用对象仍然生存则放回old链表中。
m += handle_weakrefs(&unreachable, old);
validate_list(old, 0);
validate_list(&unreachable, PREV_MASK_COLLECTING);
/* Call tp_finalize on objects which have one. */
// 执行那些具有的__del__方法的对象。
finalize_garbage(&unreachable);
// 最后，进行进行对垃圾的清除。
if (check_garbage(&unreachable)) { // clear PREV_MASK_COLLECTING here
gc_list_merge(&unreachable, old);
}
else {
/* Call tp_clear on objects in the unreachable set. This will cause
* the reference cycles to be broken. It may also cause some objects
* in finalizers to be freed.
*/
m += gc_list_size(&unreachable);
delete_garbage(state, &unreachable, old);
}
/* Collect statistics on uncollectable objects found and print
* debugging information. */
for (gc = GC_NEXT(&finalizers); gc != &finalizers; gc = GC_NEXT(gc)) {
n++;
if (state->debug & DEBUG_UNCOLLECTABLE)
debug_cycle("uncollectable", FROM_GC(gc));
}
if (state->debug & DEBUG_STATS) {
double d = _PyTime_AsSecondsDouble(_PyTime_GetMonotonicClock() - t1);
PySys_WriteStderr(
"gc: done, %" PY_FORMAT_SIZE_T "d unreachable, "
"%" PY_FORMAT_SIZE_T "d uncollectable, %.4fs elapsed\n",
n+m, n, d);
}
/* Append instances in the uncollectable set to a Python
* reachable list of garbage. The programmer has to deal with
* this if they insist on creating this type of structure.
*/
// 执行完 __del__没有，不应该被删除的对象，再重新加入到可达链表中。
handle_legacy_finalizers(state, &finalizers, old);
validate_list(old, 0);
/* Clear free list only during the collection of the highest
* generation */
if (generation == NUM_GENERATIONS-1) {
clear_freelists();
}
...
return n+m;
}
引用
v1 = [11,22,33]
v2 = v1
当对对象进行引用时候，内部引用计数器+1，原理同上。
销毁
v1 = [11,22,33] del v1
对列表对象进行销毁时，本质上就会执行引用计数器-1（同上），但当引用计数器为0时候，会执行list对象的tp_dealloc，即：
// Object/listobject.c
PyTypeObject PyList_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"list",
sizeof(PyListObject),
0,
(destructor)list_dealloc, /* tp_dealloc */
...
PyObject_GC_Del, /* tp_free */
};
/* Empty list reuse scheme to save calls to malloc and free */
#ifndef PyList_MAXFREELIST
#define PyList_MAXFREELIST 80
#endif
static PyListObject *free_list[PyList_MAXFREELIST];
static int numfree = 0;
static void
list_dealloc(PyListObject *op)
{
Py_ssize_t i;
// 从分代回收的的代中移除
PyObject_GC_UnTrack(op);
Py_TRASHCAN_BEGIN(op, list_dealloc)
if (op->ob_item != NULL) {
/* Do it backwards, for Christian Tismer.
There's a simple test case where somehow this reduces
thrashing when a *very* large list is created and
immediately deleted. */
i = Py_SIZE(op);
while (--i >= 0) {
Py_XDECREF(op->ob_item[i]);
}
PyMem_FREE(op->ob_item);
}
if (numfree < PyList_MAXFREELIST && PyList_CheckExact(op))
// free_list中还么有占满80，不销毁并缓冲在free_list中
free_list[numfree++] = op;
else
// 销毁并在refchain中移除
Py_TYPE(op)->tp_free((PyObject *)op);
Py_TRASHCAN_END
}
Tuple类型
创建
v = (11,22,33)
当创建元组时候，会执行如下源码：
// Objects/tupleobject.c
#define PyTuple_MAXSAVESIZE 20 /* Largest tuple to save on free list */
#define PyTuple_MAXFREELIST 2000 /* Maximum number of tuples of each size to save */
static PyTupleObject *free_list[PyTuple_MAXSAVESIZE]; // free_list[20] = {链表、链表..}
static int numfree[PyTuple_MAXSAVESIZE]; // numfree[2000]表示每个链表的长度
PyObject *
PyTuple_New(Py_ssize_t size)
{
PyTupleObject *op;
...
// free_list第0个元素存储的是空元祖
if (size == 0 && free_list[0]) {
op = free_list[0];
Py_INCREF(op);
return (PyObject *) op;
}
// 有缓存的tuple对象，则从free_list中获取
if (size < PyTuple_MAXSAVESIZE && (op = free_list[size]) != NULL) {
// 获取对象并初始化
free_list[size] = (PyTupleObject *) op->ob_item[0];
numfree[size]--;
Py_SIZE(op) = size;
Py_TYPE(op) = &PyTuple_Type;
// 对象加入到refchain链表。
_Py_NewReference((PyObject *)op);
}
else
{
..
// 没有缓存数据，则创建对象
op = PyObject_GC_NewVar(PyTupleObject, &PyTuple_Type, size);
if (op == NULL)
return NULL;
}
for (i=0; i < size; i++)
op->ob_item[i] = NULL;
if (size == 0) {
free_list[0] = op;
++numfree[0];
Py_INCREF(op); /* extra INCREF so that this is never freed */
}
// 对象加入到分代的链表。
_PyObject_GC_TRACK(op);
return (PyObject *) op;
}
// Includes/objimpl.h
#define PyObject_GC_NewVar(type, typeobj, n) \
( (type *) _PyObject_GC_NewVar((typeobj), (n)) )
Objects/gcmodules.c
PyVarObject *
_PyObject_GC_NewVar(PyTypeObject *tp, Py_ssize_t nitems)
{
size_t size;
PyVarObject *op;
if (nitems < 0) {
PyErr_BadInternalCall();
return NULL;
}
size = _PyObject_VAR_SIZE(tp, nitems);
// 开内存 & 分代 & 超过阈值则垃圾回收（流程同上述 列表过程）
op = (PyVarObject *) _PyObject_GC_Malloc(size);
if (op != NULL)
op = PyObject_INIT_VAR(op, tp, nitems);
return op;
}
引用
v1 = (11,22,33)
v2 = v1
引用时会触发引用计数器 + 1，具体流程同上。
销毁
v = (11,22,33) del v
销毁对象时候，执行引用计数器-1，如果计数器减为0，则触发tuple类型的tp_dealloc，详细如下：
PyTypeObject PyTuple_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"tuple",
sizeof(PyTupleObject) - sizeof(PyObject *),
sizeof(PyObject *),
(destructor)tupledealloc, /* tp_dealloc */
...
PyObject_GC_Del, /* tp_free */
};
static void
tupledealloc(PyTupleObject *op)
{
Py_ssize_t i;
Py_ssize_t len = Py_SIZE(op);
// 从分代的链表中移除
PyObject_GC_UnTrack(op);
Py_TRASHCAN_BEGIN(op, tupledealloc)
if (len > 0) {
i = len;
while (--i >= 0)
Py_XDECREF(op->ob_item[i]);
// 缓存到free_list中
if (len < PyTuple_MAXSAVESIZE && numfree[len] < PyTuple_MAXFREELIST &&
Py_TYPE(op) == &PyTuple_Type)
{
op->ob_item[0] = (PyObject *) free_list[len];
numfree[len]++;
free_list[len] = op;
// 结束
goto done; /* return */
}
}
// 不缓存，则直接销毁对象并在refchain链表中移除。
Py_TYPE(op)->tp_free((PyObject *)op);
done:
Py_TRASHCAN_END
}
Dict类型
创建
v = {"name":"小白","age":18}
当创建一个字典对象时，Python底层会执行如下源码：
#define PyDict_MAXFREELIST 80
// 缓存dict对象的free_list
static PyDictObject *free_list[PyDict_MAXFREELIST];
static int numfree = 0;
PyObject *
PyDict_New(void)
{
dictkeys_incref(Py_EMPTY_KEYS);
return new_dict(Py_EMPTY_KEYS, empty_values);
}
/* Consumes a reference to the keys object */
static PyObject *
new_dict(PyDictKeysObject *keys, PyObject **values)
{
PyDictObject *mp;
assert(keys != NULL);
// 如果有缓存，则从缓存区获取一个对象
if (numfree) {
mp = free_list[--numfree];
assert (mp != NULL);
assert (Py_TYPE(mp) == &PyDict_Type);
_Py_NewReference((PyObject *)mp);
}
else {
// 没有缓存，则去创建字典对象。（源码流程同list类型）
mp = PyObject_GC_New(PyDictObject, &PyDict_Type);
if (mp == NULL) {
dictkeys_decref(keys);
if (values != empty_values) {
free_values(values);
}
return NULL;
}
}
mp->ma_keys = keys;
mp->ma_values = values;
mp->ma_used = 0;
mp->ma_version_tag = DICT_NEXT_VERSION();
ASSERT_CONSISTENT(mp);
return (PyObject *)mp;
}
引用
v1 = {"name":"小白","age":18}
v2 = v1
出现引用，则应用计数器+1（同上）。
销毁
v1 = {"name":"小白","age":18}
del v1
销毁一个对象时候，引用计数器-1，当减到0时候，则触发dict类型的tp_dealloc，源码如下：
// Object/dictobject.c
PyTypeObject PyDict_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"dict",
sizeof(PyDictObject),
0,
(destructor)dict_dealloc, /* tp_dealloc */
...
PyObject_GC_Del, /* tp_free */
};
static void
dict_dealloc(PyDictObject *mp)
{
PyObject **values = mp->ma_values;
PyDictKeysObject *keys = mp->ma_keys;
Py_ssize_t i, n;
// 从分代链表中移除
PyObject_GC_UnTrack(mp);
Py_TRASHCAN_BEGIN(mp, dict_dealloc)
...
// 缓存区为满，则缓存
if (numfree < PyDict_MAXFREELIST && Py_TYPE(mp) == &PyDict_Type)
free_list[numfree++] = mp;
else
// 已满则销毁，并在refchain中移除。
Py_TYPE(mp)->tp_free((PyObject *)mp);
Py_TRASHCAN_END
}
