码迷,mamicode.com
首页 > 编程语言 > 详细

python垃圾回收机制的原理

时间:2020-04-21 00:05:17      阅读:102      评论:0      收藏:0      [点我收藏+]

标签:字符串   集合   void   har   car   构造   并且   dig   对象销毁   

前言

  关于研究原理这件事,简单的事重复做,好好做,专研,那就是领域的专家,枯燥的技术,持之以恒的坚持。
  现在的高级语言如java,c#等,都采用了垃圾收集机制,而不再是c,c++里用户自己管理维护内存的方式。自己管理内存极其自由,可以任意申请内存,但如同一把双刃剑,为大量内存泄露,悬空指针等bug埋下隐患。
对于一个字符串、列表、类甚至数值都是对象,且定位简单易用的语言,自然不会让用户去处理如何分配回收内存的问题。
python里也同java一样采用了垃圾收集机制,不过不一样的是:
python采用的是引用计数机制为主,标记-清除分代收集两种机制为辅的策略

1. 白话垃圾回收

用通俗的语言解释内存管理和垃圾回收的过程,搞懂这一部分就可以去面试、去装逼了…

1.1 大管家refchain

在Python的C源码中有一个名为refchain的环状双向链表,这个链表比较牛逼了,因为Python程序中一旦创建对象都会把这个对象添加到refchain这个链表中。也就是说他保存着所有的对象。例如:

  1. age = 18
  2. name = "武沛齐"

技术图片

1.2 引用计数器

在refchain中的所有对象内部都有一个ob_refcnt用来保存当前对象的引用计数器,顾名思义就是自己被引用的次数,例如:

  1. age = 18
  2. name = "武沛齐"
  3. nickname = name

上述代码表示内存中有 18 和 “武沛齐” 两个值,他们的引用计数器分别为:1、2 。
技术图片

当值被多次引用时候,不会在内存中重复创建数据,而是引用计数器+1 。 当对象被销毁时候同时会让引用计数器-1,如果引用计数器为0,则将对象从refchain链表中摘除,同时在内存中进行销毁(暂不考虑缓存等特殊情况)。

  1. age = 18
  2. number = age # 对象18的引用计数器 + 1
  3. del age # 对象18的引用计数器 - 1
  4. def run(arg):
  5. print(arg)
  6. run(number) # 刚开始执行函数时,对象18引用计数器 + 1,当函数执行完毕之后,对象18引用计数器 - 1 。
  7. num_list = [11,22,number] # 对象18的引用计数器 + 1

1.3 标记清除&分代回收

基于引用计数器进行垃圾回收非常方便和简单,但他还是存在循环引用的问题,导致无法正常的回收一些数据,例如:

  1. v1 = [11,22,33] # refchain中创建一个列表对象,由于v1=对象,所以列表引对象用计数器为1.
  2. v2 = [44,55,66] # refchain中再创建一个列表对象,因v2=对象,所以列表对象引用计数器为1.
  3. v1.append(v2) # 把v2追加到v1中,则v2对应的[44,55,66]对象的引用计数器加1,最终为2.
  4. v2.append(v1) # 把v1追加到v1中,则v1对应的[11,22,33]对象的引用计数器加1,最终为2.
  5. del v1 # 引用计数器-1
  6. del v2 # 引用计数器-1

对于上述代码会发现,执行del操作之后,没有变量再会去使用那两个列表对象,但由于循环引用的问题,他们的引用计数器不为0,所以他们的状态:永远不会被使用、也不会被销毁。项目中如果这种代码太多,就会导致内存一直被消耗,直到内存被耗尽,程序崩溃。

为了解决循环引用的问题,引入了标记清除技术,专门针对那些可能存在循环引用的对象进行特殊处理,可能存在循环应用的类型有:列表、元组、字典、集合、自定义类等那些能进行数据嵌套的类型。

标记清除:创建特殊链表专门用于保存 列表、元组、字典、集合、自定义类等对象,之后再去检查这个链表中的对象是否存在循环引用,如果存在则让双方的引用计数器均 - 1 。

分代回收:对标记清除中的链表进行优化,将那些可能存在循引用的对象拆分到3个链表,链表称为:0/1/2三代,每代都可以存储对象和阈值,当达到阈值时,就会对相应的链表中的每个对象做一次扫描,除循环引用各自减1并且销毁引用计数器为0的对象。

  1. // 分代的C源码
  2. #define NUM_GENERATIONS 3
  3. struct gc_generation generations[NUM_GENERATIONS] = {
  4. /* PyGC_Head, threshold, count */
  5. {{(uintptr_t)_GEN_HEAD(0), (uintptr_t)_GEN_HEAD(0)}, 700, 0}, // 0代
  6. {{(uintptr_t)_GEN_HEAD(1), (uintptr_t)_GEN_HEAD(1)}, 10, 0}, // 1代
  7. {{(uintptr_t)_GEN_HEAD(2), (uintptr_t)_GEN_HEAD(2)}, 10, 0}, // 2代
  8. };

特别注意:0代和1、2代的threshold和count表示的意义不同。

  • 0代,count表示0代链表中对象的数量,threshold表示0代链表对象个数阈值,超过则执行一次0代扫描检查。
  • 1代,count表示0代链表扫描的次数,threshold表示0代链表扫描的次数阈值,超过则执行一次1代扫描检查。
  • 2代,count表示1代链表扫描的次数,threshold表示1代链表扫描的次数阈值,超过则执行一2代扫描检查。

1.4 情景模拟

根据C语言底层并结合图来讲解内存管理和垃圾回收的详细过程。

第一步:当创建对象age=19时,会将对象添加到refchain链表中。

技术图片

第二步:当创建对象num_list = [11,22]时,会将列表对象添加到 refchain 和 generations 0代中。

技术图片

第三步:新创建对象使generations的0代链表上的对象数量大于阈值700时,要对链表上的对象进行扫描检查。

当0代大于阈值后,底层不是直接扫描0代,而是先判断2、1是否也超过了阈值。

  • 如果2、1代未达到阈值,则扫描0代,并让1代的 count + 1 。
  • 如果2代已达到阈值,则将2、1、0三个链表拼接起来进行全扫描,并将2、1、0代的count重置为0.
  • 如果1代已达到阈值,则讲1、0两个链表拼接起来进行扫描,并将所有1、0代的count重置为0.

对拼接起来的链表在进行扫描时,主要就是剔除循环引用和销毁垃圾,详细过程为:

  • 扫描链表,把每个对象的引用计数器拷贝一份并保存到 gc_refs中,保护原引用计数器。
  • 再次扫描链表中的每个对象,并检查是否存在循环引用,如果存在则让各自的gc_refs减 1 。
  • 再次扫描链表,将 gc_refs 为 0 的对象移动到unreachable链表中;不为0的对象直接升级到下一代链表中。
  • 处理unreachable链表中的对象的 析构函数 和 弱引用,不能被销毁的对象升级到下一代链表,能销毁的保留在此链表。
    • 析构函数,指的就是那些定义了__del__方法的对象,需要执行之后再进行销毁处理。
    • 弱引用,
  • 最后将 unreachable 中的每个对象销毁并在refchain链表中移除(不考虑缓存机制)。

至此,垃圾回收的过程结束。

1.5 缓存机制

从上文大家可以了解到当对象的引用计数器为0时,就会被销毁并释放内存。而实际上他不是这么的简单粗暴,因为反复的创建和销毁会使程序的执行效率变低。Python中引入了“缓存机制”机制。
例如:引用计数器为0时,不会真正销毁对象,而是将他放到一个名为 free_list 的链表中,之后会再创建对象时不会在重新开辟内存,而是在free_list中将之前的对象来并重置内部的值来使用。

  • float类型,维护的free_list链表最多可缓存100个float对象。

    1. v1 = 3.14 # 开辟内存来存储float对象,并将对象添加到refchain链表。
    2. print( id(v1) ) # 内存地址:4436033488
    3. del v1 # 引用计数器-1,如果为0则在rechain链表中移除,不销毁对象,而是将对象添加到float的free_list.
    4. v2 = 9.999 # 优先去free_list中获取对象,并重置为9.999,如果free_list为空才重新开辟内存。
    5. print( id(v2) ) # 内存地址:4436033488
    6. # 注意:引用计数器为0时,会先判断free_list中缓存个数是否满了,未满则将对象缓存,已满则直接将对象销毁。
  • int类型,不是基于free_list,而是维护一个small_ints链表保存常见数据(小数据池),小数据池范围:-5 <= value < 257。即:重复使用这个范围的整数时,不会重新开辟内存。

    1. v1 = 38 # 去小数据池small_ints中获取38整数对象,将对象添加到refchain并让引用计数器+1。
    2. print( id(v1)) #内存地址:4514343712
    3. v2 = 38 # 去小数据池small_ints中获取38整数对象,将refchain中的对象的引用计数器+1。
    4. print( id(v2) ) #内存地址:4514343712
    5. # 注意:在解释器启动时候-5~256就已经被加入到small_ints链表中且引用计数器初始化为1,代码中使用的值时直接去small_ints中拿来用并将引用计数器+1即可。另外,small_ints中的数据引用计数器永远不会为0(初始化时就设置为1了),所以也不会被销毁。
  • str类型,维护unicode_latin1[256]链表,内部将所有的ascii字符缓存起来,以后使用时就不再反复创建。

    1. v1 = "A"
    2. print( id(v1) ) # 输出:4517720496
    3. del v1
    4. v2 = "A"
    5. print( id(v1) ) # 输出:4517720496
    6. # 除此之外,Python内部还对字符串做了驻留机制,针对那么只含有字母、数字、下划线的字符串(见源码Objects/codeobject.c),如果内存中已存在则不会重新在创建而是使用原来的地址里(不会像free_list那样一直在内存存活,只有内存中有才能被重复利用)。
    7. v1 = "wupeiqi"
    8. v2 = "wupeiqi"
    9. print(id(v1) == id(v2)) # 输出:True
  • list类型,维护的free_list数组最多可缓存80个list对象。
    1. v1 = [11,22,33]
    2. print( id(v1) ) # 输出:4517628816
    3. del v1
    4. v2 = ["武","沛齐"]
    5. print( id(v2) ) # 输出:4517628816
  • tuple类型,维护一个free_list数组且数组容量20,数组中元素可以是链表且每个链表最多可以容纳2000个元组对象。元组的free_list数组在存储数据时,是按照元组可以容纳的个数为索引找到free_list数组中对应的链表,并添加到链表中。
    1. v1 = (1,2)
    2. print( id(v1) )
    3. del v1 # 因元组的数量为2,所以会把这个对象缓存到free_list[2]的链表中。
    4. v2 = ("武沛齐","Alex") # 不会重新开辟内存,而是去free_list[2]对应的链表中拿到一个对象来使用。
    5. print( id(v2) )
  • dict类型,维护的free_list数组最多可缓存80个dict对象。
    1. v1 = {"k1":123}
    2. print( id(v1) ) # 输出:4515998128
    3. del v1
    4. v2 = {"name":"武沛齐","age":18,"gender":"男"}
    5. print( id(v1) ) # 输出:4515998128

2. C语言源码分析

上文对Python的内存管理和垃圾回收进行了快速讲解,基本上已可以让你拿去装逼了。

接下来这一部分会让你更超神,我们要再在源码中来证实上文的内容。

2.1 两个重要的结构体

  1. #define PyObject_HEAD PyObject ob_base;
  2. #define PyObject_VAR_HEAD PyVarObject ob_base;
  3. // 宏定义,包含 上一个、下一个,用于构造双向链表用。(放到refchain链表中时,要用到)
  4. #define _PyObject_HEAD_EXTRA \
  5. struct _object *_ob_next; \
  6. struct _object *_ob_prev;
  7. typedef struct _object {
  8. _PyObject_HEAD_EXTRA // 用于构造双向链表
  9. Py_ssize_t ob_refcnt; // 引用计数器
  10. struct _typeobject *ob_type; // 数据类型
  11. } PyObject;
  12. typedef struct {
  13. PyObject ob_base; // PyObject对象
  14. Py_ssize_t ob_size; /* Number of items in variable part,即:元素个数 */
  15. } PyVarObject;

这两个结构体PyObjectPyVarObject是基石,他们保存这其他数据类型公共部分,例如:每个类型的对象在创建时都有PyObject中的那4部分数据;list/set/tuple等由多个元素组成对象创建时都有PyVarObject中的那5部分数据。

2.2 常见类型结构体

平时我们在创建一个对象时,本质上就是实例化一个相关类型的结构体,在内部保存值和引用计数器等。

  • float类型
    1. typedef struct {
    2. PyObject_HEAD
    3. double ob_fval;
    4. } PyFloatObject;
  • int类型
    1. struct _longobject {
    2. PyObject_VAR_HEAD
    3. digit ob_digit[1];
    4. };
    5. /* Long (arbitrary precision) integer object interface */
    6. typedef struct _longobject PyLongObject; /* Revealed in longintrepr.h */
  • str类型

    1. typedef struct {
    2. PyObject_HEAD
    3. Py_ssize_t length; /* Number of code points in the string */
    4. Py_hash_t hash; /* Hash value; -1 if not set */
    5. struct {
    6. unsigned int interned:2;
    7. /* Character size:
    8. - PyUnicode_WCHAR_KIND (0):
    9. * character type = wchar_t (16 or 32 bits, depending on the
    10. platform)
    11. - PyUnicode_1BYTE_KIND (1):
    12. * character type = Py_UCS1 (8 bits, unsigned)
    13. * all characters are in the range U+0000-U+00FF (latin1)
    14. * if ascii is set, all characters are in the range U+0000-U+007F
    15. (ASCII), otherwise at least one character is in the range
    16. U+0080-U+00FF
    17. - PyUnicode_2BYTE_KIND (2):
    18. * character type = Py_UCS2 (16 bits, unsigned)
    19. * all characters are in the range U+0000-U+FFFF (BMP)
    20. * at least one character is in the range U+0100-U+FFFF
    21. - PyUnicode_4BYTE_KIND (4):
    22. * character type = Py_UCS4 (32 bits, unsigned)
    23. * all characters are in the range U+0000-U+10FFFF
    24. * at least one character is in the range U+10000-U+10FFFF
    25. */
    26. unsigned int kind:3;
    27. unsigned int compact:1;
    28. unsigned int ascii:1;
    29. unsigned int ready:1;
    30. unsigned int :24;
    31. } state;
    32. wchar_t *wstr; /* wchar_t representation (null-terminated) */
    33. } PyASCIIObject;
    34. typedef struct {
    35. PyASCIIObject _base;
    36. Py_ssize_t utf8_length; /* Number of bytes in utf8, excluding the
    37. * terminating \0. */
    38. char *utf8; /* UTF-8 representation (null-terminated) */
    39. Py_ssize_t wstr_length; /* Number of code points in wstr, possible
    40. * surrogates count as two code points. */
    41. } PyCompactUnicodeObject;
    42. typedef struct {
    43. PyCompactUnicodeObject _base;
    44. union {
    45. void *any;
    46. Py_UCS1 *latin1;
    47. Py_UCS2 *ucs2;
    48. Py_UCS4 *ucs4;
    49. } data; /* Canonical, smallest-form Unicode buffer */
    50. } PyUnicodeObject;
  • list类型
    1. typedef struct {
    2. PyObject_VAR_HEAD
    3. PyObject **ob_item;
    4. Py_ssize_t allocated;
    5. } PyListObject;
  • tuple类型
    1. typedef struct {
    2. PyObject_VAR_HEAD
    3. PyObject *ob_item[1];
    4. } PyTupleObject;
  • dict类型
    1. typedef struct {
    2. PyObject_HEAD
    3. Py_ssize_t ma_used;
    4. PyDictKeysObject *ma_keys;
    5. PyObject **ma_values;
    6. } PyDictObject;

通过常见结构体可以基本了解到本质上每个对象内部会存储的数据。

扩展:在结构体部分你应该发现了str类型比较繁琐,那是因为python字符串在处理时需要考虑到编码的问题,在内部规定(见源码结构体):

  • 字符串只包含ascii,则每个字符用1个字节表示,即:latin1

  • 字符串包含中文等,则每个字符用2个字节表示,即:ucs2

  • 字符串包含emoji等,则每个字符用4个字节表示,即:ucs4

技术图片

2.3 Float类型

2.3.1 创建

  1. val = 3.14

类似于这样创建一个float对象时,会执行C源码中的如下代码:

  1. // Objects/floatobject.c
  2. // 用于缓存float对象的链表
  3. static PyFloatObject *free_list = NULL;
  4. static int numfree = 0;
  5. PyObject *
  6. PyFloat_FromDouble(double fval)
  7. {
  8. // 如果free_list中有可用对象,则从free_list链表拿出来一个;否则为对象重新开辟内存。
  9. PyFloatObject *op = free_list;
  10. if (op != NULL) {
  11. free_list = (PyFloatObject *) Py_TYPE(op);
  12. numfree--;
  13. } else {
  14. // 根据float类型的大小,为float对象新开辟内存。
  15. op = (PyFloatObject*) PyObject_MALLOC(sizeof(PyFloatObject));
  16. if (!op)
  17. return PyErr_NoMemory();
  18. }
  19. // 对float对象进行初始化,例如:引用计数器初始化为1、添加到refchain链表等。
  20. /* Inline PyObject_New */
  21. (void)PyObject_INIT(op, &PyFloat_Type);
  22. // 对float对象赋值。即:op->ob_fval = 3.14
  23. op->ob_fval = fval;
  24. return (PyObject *) op;
  25. }
  1. // Include/objimpl.h
  2. #define PyObject_INIT(op, typeobj) \
  3. ( Py_TYPE(op) = (typeobj), _Py_NewReference((PyObject *)(op)), (op) )
  1. // Objects/object.c
  2. // 维护了所有对象的一个环状双向链表
  3. static PyObject refchain = {&refchain, &refchain};
  4. void
  5. _Py_AddToAllObjects(PyObject *op, int force)
  6. {
  7. if (force || op->_ob_prev == NULL) {
  8. op->_ob_next = refchain._ob_next;
  9. op->_ob_prev = &refchain;
  10. refchain._ob_next->_ob_prev = op;
  11. refchain._ob_next = op;
  12. }
  13. }
  14. void
  15. _Py_NewReference(PyObject *op)
  16. {
  17. _Py_INC_REFTOTAL;
  18. // 引用计数器初始化为1。
  19. op->ob_refcnt = 1;
  20. // 对象添加到双向链表refchain中。
  21. _Py_AddToAllObjects(op, 1);
  22. _Py_INC_TPALLOCS(op);
  23. }

2.3.2 引用

  1. val = 3.14
  2. data = val

在项目中如果出现这种引用关系时,会将原对象的引用计数器+1。
C源码执行流程如下:

  1. // Include/object.h
  2. static inline void _Py_INCREF(PyObject *op)
  3. {
  4. _Py_INC_REFTOTAL;
  5. // 对象的引用计数器 + 1
  6. op->ob_refcnt++;
  7. }
  8. #define Py_INCREF(op) _Py_INCREF(_PyObject_CAST(op))

2.3.3 销毁

  1. val = 3.14
  2. del val

在项目中如果出现这种删除的语句,则内部会将引用计数器-1,如果引用计数器减为0,则进行缓存或垃圾回收。
C源码执行流程如下:

  1. // Include/object.h
  2. static inline void _Py_DECREF(const char *filename, int lineno,
  3. PyObject *op)
  4. {
  5. (void)filename; /* may be unused, shut up -Wunused-parameter */
  6. (void)lineno; /* may be unused, shut up -Wunused-parameter */
  7. _Py_DEC_REFTOTAL;
  8. // 引用计数器-1,如果引用计数器为0,则执行 _Py_Dealloc去缓存或垃圾回收。
  9. if (--op->ob_refcnt != 0) {
  10. #ifdef Py_REF_DEBUG
  11. if (op->ob_refcnt < 0) {
  12. _Py_NegativeRefcount(filename, lineno, op);
  13. }
  14. #endif
  15. }
  16. else {
  17. _Py_Dealloc(op);
  18. }
  19. }
  20. #define Py_DECREF(op) _Py_DECREF(__FILE__, __LINE__, _PyObject_CAST(op))
  1. // Objects/object.c
  2. void
  3. _Py_Dealloc(PyObject *op)
  4. {
  5. // 找到float类型的 tp_dealloc 函数
  6. destructor dealloc = Py_TYPE(op)->tp_dealloc;
  7. // 在refchain双向链表中摘除此对象。
  8. _Py_ForgetReference(op);
  9. // 执行float类型的 tp_dealloc 函数,去进行缓存或垃圾回收。
  10. (*dealloc)(op);
  11. }
  12. void
  13. _Py_ForgetReference(PyObject *op)
  14. {
  15. ...
  16. // 在refchain链表中移除此对象
  17. op->_ob_next->_ob_prev = op->_ob_prev;
  18. op->_ob_prev->_ob_next = op->_ob_next;
  19. op->_ob_next = op->_ob_prev = NULL;
  20. _Py_INC_TPFREES(op);
  21. }
  1. // Objects/floatobject.c
  2. #define PyFloat_MAXFREELIST 100
  3. static int numfree = 0;
  4. static PyFloatObject *free_list = NULL;
  5. // float类型中函数的对应关系
  6. PyTypeObject PyFloat_Type = {
  7. PyVarObject_HEAD_INIT(&PyType_Type, 0)
  8. "float",
  9. sizeof(PyFloatObject),
  10. 0,
  11. // tp_dealloc表示执行float_dealloc方法
  12. (destructor)float_dealloc, /* tp_dealloc */
  13. 0, /* tp_print */
  14. ...
  15. };
  16. static void
  17. float_dealloc(PyFloatObject *op)
  18. {
  19. // 检测是否是float类型
  20. if (PyFloat_CheckExact(op)) {
  21. // 检测free_list中缓存的个数是否已满,如果已满,则直接将对象销毁。
  22. if (numfree >= PyFloat_MAXFREELIST) {
  23. // 销毁
  24. PyObject_FREE(op);
  25. return;
  26. }
  27. // 将对象加入到free_list链表中
  28. numfree++;
  29. Py_TYPE(op) = (struct _typeobject *)free_list;
  30. free_list = op;
  31. }
  32. else
  33. Py_TYPE(op)->tp_free((PyObject *)op);
  34. }

2.4 int类型

2.4.1 创建

  1. age = 19

当在python中创建一个整型数据时,底层会触发他的如下源码:

  1. PyObject *
  2. PyLong_FromLong(long ival)
  3. {
  4. PyLongObject *v;
  5. ...
  6. // 优先去小数据池中检查,如果在范围内则直接获取不再重新开辟内存。( -5 <= value < 257)
  7. CHECK_SMALL_INT(ival);
  8. ...
  9. // 非小数字池中的值,重新开辟内存并初始化
  10. v = _PyLong_New(ndigits);
  11. if (v != NULL) {
  12. digit *p = v->ob_digit;
  13. Py_SIZE(v) = ndigits*sign;
  14. t = abs_ival;
  15. ...
  16. }
  17. return (PyObject *)v;
  18. }
  19. #define NSMALLNEGINTS 5
  20. #define NSMALLPOSINTS 257
  21. #define CHECK_SMALL_INT(ival) \
  22. do if (-NSMALLNEGINTS <= ival && ival < NSMALLPOSINTS) { \
  23. return get_small_int((sdigit)ival); \
  24. } while(0)
  25. static PyObject *
  26. get_small_int(sdigit ival)
  27. {
  28. PyObject *v;
  29. v = (PyObject *)&small_ints[ival + NSMALLNEGINTS];
  30. // 引用计数器 + 1
  31. Py_INCREF(v);
  32. ...
  33. return v;
  34. }
  35. PyLongObject *
  36. _PyLong_New(Py_ssize_t size)
  37. {
  38. // 创建PyLongObject的指针变量
  39. PyLongObject *result;
  40. ...
  41. // 根据长度进行开辟内存
  42. result = PyObject_MALLOC(offsetof(PyLongObject, ob_digit) +
  43. size*sizeof(digit));
  44. ...
  45. // 对内存中的数据进行初始化并添加到refchain链表中。
  46. return (PyLongObject*)PyObject_INIT_VAR(result, &PyLong_Type, size);
  47. }
  1. // Include/objimpl.h
  2. #define PyObject_NewVar(type, typeobj, n) \
  3. ( (type *) _PyObject_NewVar((typeobj), (n)) )
  4. static inline PyVarObject*
  5. _PyObject_INIT_VAR(PyVarObject *op, PyTypeObject *typeobj, Py_ssize_t size)
  6. {
  7. assert(op != NULL);
  8. Py_SIZE(op) = size;
  9. // 对象初始化
  10. PyObject_INIT((PyObject *)op, typeobj);
  11. return op;
  12. }
  13. #define PyObject_INIT(op, typeobj) \
  14. _PyObject_INIT(_PyObject_CAST(op), (typeobj))
  15. static inline PyObject*
  16. _PyObject_INIT(PyObject *op, PyTypeObject *typeobj)
  17. {
  18. assert(op != NULL);
  19. Py_TYPE(op) = typeobj;
  20. if (PyType_GetFlags(typeobj) & Py_TPFLAGS_HEAPTYPE) {
  21. Py_INCREF(typeobj);
  22. }
  23. // 对象初始化,并把对象加入到refchain链表。
  24. _Py_NewReference(op);
  25. return op;
  26. }
  1. // Objects/object.c
  2. // 维护了所有对象的一个环状双向链表
  3. static PyObject refchain = {&refchain, &refchain};
  4. void
  5. _Py_AddToAllObjects(PyObject *op, int force)
  6. {
  7. if (force || op->_ob_prev == NULL) {
  8. op->_ob_next = refchain._ob_next;
  9. op->_ob_prev = &refchain;
  10. refchain._ob_next->_ob_prev = op;
  11. refchain._ob_next = op;
  12. }
  13. }
  14. void
  15. _Py_NewReference(PyObject *op)
  16. {
  17. _Py_INC_REFTOTAL;
  18. // 引用计数器初始化为1。
  19. op->ob_refcnt = 1;
  20. // 对象添加到双向链表refchain中。
  21. _Py_AddToAllObjects(op, 1);
  22. _Py_INC_TPALLOCS(op);
  23. }

2.4.2 引用

  1. value = 69
  2. data = value

类似于出现这种引用关系时,内部其实就是将对象的引用计数器+1,源码同float类型引用。

2.4.3 销毁

  1. value = 699
  2. del value

在项目中如果出现这种删除的语句,则内部会将引用计数器-1,如果引用计数器减为0,则直接进行垃圾回收。(int类型是基于小数据池而不是free_list做的缓存,所以不会在销毁时缓存数据)。
C源码执行流程如下:

  1. // Include/object.h
  2. static inline void _Py_DECREF(const char *filename, int lineno,
  3. PyObject *op)
  4. {
  5. (void)filename; /* may be unused, shut up -Wunused-parameter */
  6. (void)lineno; /* may be unused, shut up -Wunused-parameter */
  7. _Py_DEC_REFTOTAL;
  8. // 引用计数器-1,如果引用计数器为0,则执行 _Py_Dealloc去垃圾回收。
  9. if (--op->ob_refcnt != 0) {
  10. #ifdef Py_REF_DEBUG
  11. if (op->ob_refcnt < 0) {
  12. _Py_NegativeRefcount(filename, lineno, op);
  13. }
  14. #endif
  15. }
  16. else {
  17. _Py_Dealloc(op);
  18. }
  19. }
  20. #define Py_DECREF(op) _Py_DECREF(__FILE__, __LINE__, _PyObject_CAST(op))
  1. // Objects/object.c
  2. void
  3. _Py_Dealloc(PyObject *op)
  4. {
  5. // 找到int类型的 tp_dealloc 函数(int类中没有定义tp_dealloc函数,需要去父级PyBaseObject_Type中找tp_dealloc函数)
  6. // 此处体现所有的类型都继承object
  7. destructor dealloc = Py_TYPE(op)->tp_dealloc;
  8. // 在refchain双向链表中摘除此对象。
  9. _Py_ForgetReference(op);
  10. // 执行int类型的 tp_dealloc 函数,去进行垃圾回收。
  11. (*dealloc)(op);
  12. }
  13. void
  14. _Py_ForgetReference(PyObject *op)
  15. {
  16. ...
  17. // 在refchain链表中移除此对象
  18. op->_ob_next->_ob_prev = op->_ob_prev;
  19. op->_ob_prev->_ob_next = op->_ob_next;
  20. op->_ob_next = op->_ob_prev = NULL;
  21. _Py_INC_TPFREES(op);
  22. }
  1. // Objects/longobjet.c
  2. PyTypeObject PyLong_Type = {
  3. PyVarObject_HEAD_INIT(&PyType_Type, 0)
  4. "int", /* tp_name */
  5. offsetof(PyLongObject, ob_digit), /* tp_basicsize */
  6. sizeof(digit), /* tp_itemsize */
  7. 0, /* tp_dealloc */
  8. ...
  9. PyObject_Del, /* tp_free */
  10. };
  1. Objects/typeobject.c
  2. PyTypeObject PyBaseObject_Type = {
  3. PyVarObject_HEAD_INIT(&PyType_Type, 0)
  4. "object", /* tp_name */
  5. sizeof(PyObject), /* tp_basicsize */
  6. 0, /* tp_itemsize */
  7. object_dealloc, /* tp_dealloc */
  8. ...
  9. PyObject_Del, /* tp_free */
  10. };
  11. static void
  12. object_dealloc(PyObject *self)
  13. {
  14. // 调用int类型的 tp_free,即:PyObject_Del去销毁对象。
  15. Py_TYPE(self)->tp_free(self);
  16. }

2.5 str类型

2.5.1 创建

  1. name = "武沛齐"

当在python中创建一个字符串数据时,底层会触发他的如下源码:

  1. Objects/unicodeobject.c
  2. PyObject *
  3. PyUnicode_DecodeUTF8Stateful(const char *s,Py_ssize_t size,const char *errors,Py_ssize_t *consumed)
  4. {
  5. return unicode_decode_utf8(s, size, _Py_ERROR_UNKNOWN, errors, consumed);
  6. }
  7. static PyObject *
  8. unicode_decode_utf8(const char *s, Py_ssize_t size,_Py_error_handler error_handler, const char *errors,Py_ssize_t *consumed);
  9. {
  10. ...
  11. // 如果字符串长度为1,并且是ascii字符,直接去缓存链表 *unicode_latin1[256] 中获取。
  12. if (size == 1 && (unsigned char)s[0] < 128) {
  13. if (consumed)
  14. *consumed = 1;
  15. return get_latin1_char((unsigned char)s[0]);
  16. }
  17. // 对传入的utf-8的字节进行处理,并选择合适的方式转换成unicode字符串。(latin2/ucs2/ucs4)。
  18. ...
  19. return _PyUnicodeWriter_Finish(&writer);
  20. }
  21. static PyObject*
  22. get_latin1_char(unsigned char ch)
  23. {
  24. PyObject *unicode = unicode_latin1[ch];
  25. if (!unicode) {
  26. unicode = PyUnicode_New(1, ch);
  27. if (!unicode)
  28. return NULL;
  29. PyUnicode_1BYTE_DATA(unicode)[0] = ch;
  30. assert(_PyUnicode_CheckConsistency(unicode, 1));
  31. unicode_latin1[ch] = unicode;
  32. }
  33. Py_INCREF(unicode);
  34. return unicode;
  35. }
  36. PyObject *
  37. _PyUnicodeWriter_Finish(_PyUnicodeWriter *writer)
  38. {
  39. PyObject *str;
  40. // 写入值到str
  41. str = writer->buffer;
  42. writer->buffer = NULL;
  43. if (writer->readonly) {
  44. assert(PyUnicode_GET_LENGTH(str) == writer->pos);
  45. return str;
  46. }
  47. if (PyUnicode_GET_LENGTH(str) != writer->pos) {
  48. PyObject *str2;
  49. // 创建对象
  50. str2 = resize_compact(str, writer->pos);
  51. if (str2 == NULL) {
  52. Py_DECREF(str);
  53. return NULL;
  54. }
  55. str = str2;
  56. }
  57. assert(_PyUnicode_CheckConsistency(str, 1));
  58. return unicode_result_ready(str);
  59. }
  60. static PyObject*
  61. resize_compact(PyObject *unicode, Py_ssize_t length)
  62. {
  63. ...
  64. // 开辟内存
  65. new_unicode = (PyObject *)PyObject_REALLOC(unicode, new_size);
  66. if (new_unicode == NULL) {
  67. _Py_NewReference(unicode);
  68. PyErr_NoMemory();
  69. return NULL;
  70. }
  71. unicode = new_unicode;
  72. // 把对象加入到refchain链表
  73. _Py_NewReference(unicode);
  74. ...
  75. return unicode;
  76. }

在字符串中除了会执行上述代码之外,还会执行以下代码实现内部的驻留机制。为了更好的理解,你可以认为驻留机制:将字符串保存到一个名为 interned 的字典中,以后再使用时 直接去字典中获取不再需要创建。

实际在源码中每次都会创建新的字符串,只不过在内部检测是否已驻留到interned中,如果在则使用interned内部的原来的字符串,把新创建的字符串当做垃圾去回收。

  1. Objects/unicodeobject.c
  2. void
  3. PyUnicode_InternInPlace(PyObject **p)
  4. {
  5. PyObject *s = *p;
  6. PyObject *t;
  7. #ifdef Py_DEBUG
  8. assert(s != NULL);
  9. assert(_PyUnicode_CHECK(s));
  10. #else
  11. if (s == NULL || !PyUnicode_Check(s))
  12. return;
  13. #endif
  14. /* If it‘s a subclass, we don‘t really know what putting
  15. it in the interned dict might do. */
  16. if (!PyUnicode_CheckExact(s))
  17. return;
  18. if (PyUnicode_CHECK_INTERNED(s))
  19. return;
  20. if (interned == NULL) {
  21. interned = PyDict_New();
  22. if (interned == NULL) {
  23. PyErr_Clear(); /* Don‘t leave an exception */
  24. return;
  25. }
  26. }
  27. Py_ALLOW_RECURSION
  28. // 将新字符串驻留到interned字典中,不存在则驻留,已存在则不再重复驻留。
  29. t = PyDict_SetDefault(interned, s, s);
  30. Py_END_ALLOW_RECURSION
  31. if (t == NULL) {
  32. PyErr_Clear();
  33. return;
  34. }
  35. // 存在,使用已驻留的字符串 并 将引用计数器+1
  36. if (t != s) {
  37. Py_INCREF(t);
  38. Py_SETREF(*p, t); // 处理临时对象
  39. return;
  40. }
  41. /* The two references in interned are not counted by refcnt.
  42. The deallocator will take care of this */
  43. Py_REFCNT(s) -= 2; // 让临时对象可被回收。
  44. _PyUnicode_STATE(s).interned = SSTATE_INTERNED_MORTAL;
  45. }

2.5.2 引用

同上,引用计数器 + 1 .

2.5.3 销毁

  1. val = "武沛齐"
  2. del val

在项目中如果出现这种删除的语句,则内部会将引用计数器-1,如果引用计数器减为0,则进行缓存或垃圾回收。

  1. // Include/object.h
  2. static inline void _Py_DECREF(const char *filename, int lineno,
  3. PyObject *op)
  4. {
  5. (void)filename; /* may be unused, shut up -Wunused-parameter */
  6. (void)lineno; /* may be unused, shut up -Wunused-parameter */
  7. _Py_DEC_REFTOTAL;
  8. // 引用计数器-1,如果引用计数器为0,则执行 _Py_Dealloc去缓存或垃圾回收。
  9. if (--op->ob_refcnt != 0) {
  10. #ifdef Py_REF_DEBUG
  11. if (op->ob_refcnt < 0) {
  12. _Py_NegativeRefcount(filename, lineno, op);
  13. }
  14. #endif
  15. }
  16. else {
  17. _Py_Dealloc(op);
  18. }
  19. }
  20. #define Py_DECREF(op) _Py_DECREF(__FILE__, __LINE__, _PyObject_CAST(op))
  1. // Objects/object.c
  2. void
  3. _Py_Dealloc(PyObject *op)
  4. {
  5. // 找到str类型的 tp_dealloc 函数
  6. destructor dealloc = Py_TYPE(op)->tp_dealloc;
  7. // 在refchain双向链表中摘除此对象。
  8. _Py_ForgetReference(op);
  9. // 执行float类型的 tp_dealloc 函数,去进行缓存或垃圾回收。
  10. (*dealloc)(op);
  11. }
  12. void
  13. _Py_ForgetReference(PyObject *op)
  14. {
  15. ...
  16. // 在refchain链表中移除此对象
  17. op->_ob_next->_ob_prev = op->_ob_prev;
  18. op->_ob_prev->_ob_next = op->_ob_next;
  19. op->_ob_next = op->_ob_prev = NULL;
  20. _Py_INC_TPFREES(op);
  21. }
  1. // Objects/unicodeobject.c
  2. PyTypeObject PyUnicode_Type = {
  3. PyVarObject_HEAD_INIT(&PyType_Type, 0)
  4. "str", /* tp_name */
  5. sizeof(PyUnicodeObject), /* tp_basicsize */
  6. 0, /* tp_itemsize */
  7. /* Slots */
  8. (destructor)unicode_dealloc, /* tp_dealloc */
  9. ...
  10. PyObject_Del, /* tp_free */
  11. };
  12. static void
  13. unicode_dealloc(PyObject *unicode)
  14. {
  15. switch (PyUnicode_CHECK_INTERNED(unicode)) {
  16. case SSTATE_NOT_INTERNED:
  17. break;
  18. case SSTATE_INTERNED_MORTAL:
  19. /* revive dead object temporarily for DelItem */
  20. Py_REFCNT(unicode) = 3;
  21. // 在interned中删除驻留的字符串
  22. if (PyDict_DelItem(interned, unicode) != 0)
  23. Py_FatalError(
  24. "deletion of interned string failed");
  25. break;
  26. case SSTATE_INTERNED_IMMORTAL:
  27. Py_FatalError("Immortal interned string died.");
  28. /* fall through */
  29. default:
  30. Py_FatalError("Inconsistent interned string state.");
  31. }
  32. if (_PyUnicode_HAS_WSTR_MEMORY(unicode))
  33. PyObject_DEL(_PyUnicode_WSTR(unicode));
  34. if (_PyUnicode_HAS_UTF8_MEMORY(unicode))
  35. PyObject_DEL(_PyUnicode_UTF8(unicode));
  36. if (!PyUnicode_IS_COMPACT(unicode) && _PyUnicode_DATA_ANY(unicode))
  37. PyObject_DEL(_PyUnicode_DATA_ANY(unicode));
  38. // 内存中销毁对象
  39. Py_TYPE(unicode)->tp_free(unicode);
  40. }

2.6 list类型

2.6.1 创建

  1. v = [11,22,33]

当创建一个列表时候,内部的C源码会执行如下:

  1. // Objects/listobject.c
  2. #define PyList_MAXFREELIST 80
  3. // free_list用于对list对象进行缓存,最多可缓存80个对象
  4. static PyListObject *free_list[PyList_MAXFREELIST];
  5. // free_list中可用的对象
  6. static int numfree = 0;
  7. PyObject *
  8. PyList_New(Py_ssize_t size)
  9. {
  10. PyListObject *op;
  11. if (size < 0) {
  12. PyErr_BadInternalCall();
  13. return NULL;
  14. }
  15. if (numfree) {
  16. // 如果free_list中有缓存的对象,则直接从free_list中获取一个对象来使用。
  17. numfree--;
  18. op = free_list[numfree];
  19. _Py_NewReference((PyObject *)op);
  20. } else {
  21. // 缓存中没有,则需要 开辟内存 & 初始化对象
  22. op = PyObject_GC_New(PyListObject, &PyList_Type);
  23. if (op == NULL)
  24. return NULL;
  25. }
  26. if (size <= 0)
  27. op->ob_item = NULL;
  28. else {
  29. op->ob_item = (PyObject **) PyMem_Calloc(size, sizeof(PyObject *));
  30. if (op->ob_item == NULL) {
  31. Py_DECREF(op);
  32. return PyErr_NoMemory();
  33. }
  34. }
  35. Py_SIZE(op) = size;
  36. op->allocated = size;
  37. // 把对象加入到分代回收的三代中的0代链表中。
  38. _PyObject_GC_TRACK(op);
  39. return (PyObject *) op;
  40. }
  1. static inline void _PyObject_GC_TRACK_impl(const char *filename, int lineno,
  2. PyObject *op)
  3. {
  4. _PyObject_ASSERT_FROM(op, !_PyObject_GC_IS_TRACKED(op),
  5. "object already tracked by the garbage collector",
  6. filename, lineno, "_PyObject_GC_TRACK");
  7. PyGC_Head *gc = _Py_AS_GC(op);
  8. _PyObject_ASSERT_FROM(op,
  9. (gc->_gc_prev & _PyGC_PREV_MASK_COLLECTING) == 0,
  10. "object is in generation which is garbage collected",
  11. filename, lineno, "_PyObject_GC_TRACK");
  12. // 把对象加入到链表中,链表尾部还是gc.generation0。
  13. PyGC_Head *last = (PyGC_Head*)(_PyRuntime.gc.generation0->_gc_prev);
  14. _PyGCHead_SET_NEXT(last, gc);
  15. _PyGCHead_SET_PREV(gc, last);
  16. _PyGCHead_SET_NEXT(gc, _PyRuntime.gc.generation0);
  17. _PyRuntime.gc.generation0->_gc_prev = (uintptr_t)gc;
  18. }
  19. #define _PyObject_GC_TRACK(op) \
  20. _PyObject_GC_TRACK_impl(__FILE__, __LINE__, _PyObject_CAST(op))
  1. Include/objimpl.h
  2. #define PyObject_GC_New(type, typeobj) \
  3. ( (type *) _PyObject_GC_New(typeobj) )
  1. //Modules/gcmodule.c
  2. PyObject *
  3. _PyObject_GC_New(PyTypeObject *tp)
  4. {
  5. // 创建对象
  6. PyObject *op = _PyObject_GC_Malloc(_PyObject_SIZE(tp));
  7. if (op != NULL)
  8. // 初始化对象并把对象加入到refchain链表中。
  9. op = PyObject_INIT(op, tp);
  10. return op;
  11. }
  12. PyObject *
  13. _PyObject_GC_Malloc(size_t basicsize)
  14. {
  15. return _PyObject_GC_Alloc(0, basicsize);
  16. }
  17. static PyObject *
  18. _PyObject_GC_Alloc(int use_calloc, size_t basicsize)
  19. {
  20. // 包含分代回收的三代链表
  21. struct _gc_runtime_state *state = &_PyRuntime.gc;
  22. PyObject *op;
  23. PyGC_Head *g;
  24. size_t size;
  25. if (basicsize > PY_SSIZE_T_MAX - sizeof(PyGC_Head))
  26. return PyErr_NoMemory();
  27. size = sizeof(PyGC_Head) + basicsize;
  28. // 创建 gc head
  29. if (use_calloc)
  30. g = (PyGC_Head *)PyObject_Calloc(1, size);
  31. else
  32. g = (PyGC_Head *)PyObject_Malloc(size);
  33. if (g == NULL)
  34. return PyErr_NoMemory();
  35. assert(((uintptr_t)g & 3) == 0); // g must be aligned 4bytes boundary
  36. g->_gc_next = 0;
  37. g->_gc_prev = 0;
  38. // 分代回收的0代数量+1
  39. state->generations[0].count++; /* number of allocated GC objects */
  40. // 如果0代超出自己的阈值,进行垃圾分代回收。
  41. if (state->generations[0].count > state->generations[0].threshold && state->enabled && state->generations[0].threshold && !state->collecting && !PyErr_Occurred())
  42. {
  43. // 正在收集
  44. state->collecting = 1;
  45. // 去进行垃圾回收收集
  46. collect_generations(state);
  47. // 结束收集
  48. state->collecting = 0;
  49. }
  50. op = FROM_GC(g);
  51. return op;
  52. }
  53. /* Get the object given the GC head */
  54. #define FROM_GC(g) ((PyObject *)(((PyGC_Head *)g)+1))
  55. static Py_ssize_t
  56. collect_generations(struct _gc_runtime_state *state)
  57. {
  58. Py_ssize_t n = 0;
  59. // 倒序循环三代,按照:2、1、0顺序
  60. for (int i = NUM_GENERATIONS-1; i >= 0; i--) {
  61. if (state->generations[i].count > state->generations[i].threshold) {
  62. if (i == NUM_GENERATIONS - 1 && state->long_lived_pending < state->long_lived_total / 4)
  63. continue;
  64. // 去进行回收,回收当前代之前的所有代。
  65. n = collect_with_callback(state, i);
  66. break;
  67. }
  68. }
  69. return n;
  70. }
  71. static Py_ssize_t
  72. collect_with_callback(struct _gc_runtime_state *state, int generation)
  73. {
  74. ...
  75. // 回收,0、1、2代(通过引用传参获取 已回收的和未回收的链表)
  76. result = collect(state, generation, &collected, &uncollectable, 0);
  77. ...
  78. return result;
  79. }
  80. /* This is the main function. Read this to understand how the collection process works. */
  81. static Py_ssize_t
  82. collect(struct _gc_runtime_state *state, int generation,
  83. Py_ssize_t *n_collected, Py_ssize_t *n_uncollectable, int nofail)
  84. {
  85. int i;
  86. Py_ssize_t m = 0; /* # objects collected */
  87. Py_ssize_t n = 0; /* # unreachable objects that couldn‘t be collected */
  88. PyGC_Head *young; /* the generation we are examining */
  89. PyGC_Head *old; /* next older generation */
  90. PyGC_Head unreachable; /* non-problematic unreachable trash */
  91. PyGC_Head finalizers; /* objects with, & reachable from, __del__ */
  92. PyGC_Head *gc;
  93. _PyTime_t t1 = 0; /* initialize to prevent a compiler warning */
  94. /* update collection and allocation counters */
  95. // generation分别会是 0 1 2
  96. // 让当前执行收集的代的更高级的代的count加1 ?例如:0带时,让1代的count+1
  97. // 因为当前带扫描一次,则更高级代count+1,当前带扫描到10次时,更高级的带要扫描一次。
  98. if (generation+1 < NUM_GENERATIONS)
  99. state->generations[generation+1].count += 1;
  100. // 比当前代低的代的count设置为0,因为当前带扫描时候会携带年轻带一起扫描,本次扫描之后对象都会升级到高级别的带,年轻代则为0
  101. for (i = 0; i <= generation; i++)
  102. state->generations[i].count = 0;
  103. // 总结:比当前扫描的代高的带count+1,自己和比自己低的代count设置为0.
  104. // 将比自己代低的所有代,搞到一个链表中
  105. // #define GEN_HEAD(state, n) (&(state)->generations[n].head)
  106. for (i = 0; i < generation; i++) {
  107. gc_list_merge(GEN_HEAD(state, i), GEN_HEAD(state, generation));
  108. }
  109. // 获取当前代的head(链表头)
  110. // #define GEN_HEAD(state, n) (&(state)->generations[n].head)
  111. young = GEN_HEAD(state, generation);
  112. // 比当前代老的head(链表头),如果是0、1、2中的2代时,则两个值相等。
  113. if (generation < NUM_GENERATIONS-1)
  114. //0、1代
  115. old = GEN_HEAD(state, generation+1);
  116. else
  117. //2代
  118. old = young;
  119. // 循环当前代(包含比自己年轻的代的链表)重的每个元素,将引用计数器拷贝到gc_refs中。
  120. // 拷贝出来的用于以后做计数器的计算,不回去更改原来的引用计数器的值。
  121. update_refs(young); // gc_prev is used for gc_refs
  122. // 处理循环引用,把循环引用的位置值为0.
  123. subtract_refs(young);
  124. // 将链表中所有引用计数器为0的,移动到unreachable链表(不可达链表)。
  125. // 循环young链表中的每个元素,并根据拷贝的引用计数器gc_refs进行判断,如果为0则放入不可达链表;
  126. gc_list_init(&unreachable);
  127. move_unreachable(young, &unreachable); // gc_prev is pointer again
  128. validate_list(young, 0);
  129. untrack_tuples(young);
  130. /* Move reachable objects to next generation. */
  131. // 将可达对象加入到下一代。
  132. if (young != old) {
  133. // 如果是0、1代,则升级到下一代。
  134. if (generation == NUM_GENERATIONS - 2) {
  135. // 如果是1代,则更新
  136. state->long_lived_pending += gc_list_size(young);
  137. }
  138. // 把young链表拼接到old链表中。
  139. gc_list_merge(young, old);
  140. }
  141. else {
  142. /* We only untrack dicts in full collections, to avoid quadratic
  143. dict build-up. See issue #14775. */
  144. // 如果是2代,则更新long_lived_total和long_lived_pending
  145. untrack_dicts(young);
  146. state->long_lived_pending = 0;
  147. state->long_lived_total = gc_list_size(young);
  148. }
  149. // 循环所有不可达的元素,把具有 __del__ 方法对象放到finalizers链表中。
  150. // 调用__del__之后,再会进行让他们在销毁。
  151. gc_list_init(&finalizers);
  152. // NEXT_MASK_UNREACHABLE is cleared here.
  153. // After move_legacy_finalizers(), unreachable is normal list.
  154. move_legacy_finalizers(&unreachable, &finalizers);
  155. /* finalizers contains the unreachable objects with a legacy finalizer;
  156. * unreachable objects reachable *from* those are also uncollectable,
  157. * and we move those into the finalizers list too.
  158. */
  159. move_legacy_finalizer_reachable(&finalizers);
  160. validate_list(&finalizers, 0);
  161. validate_list(&unreachable, PREV_MASK_COLLECTING);
  162. ...
  163. /* Clear weakrefs and invoke callbacks as necessary. */
  164. // 循环所有的不可达元素,处理所有弱引用到unreachable,如果弱引用对象仍然生存则放回old链表中。
  165. m += handle_weakrefs(&unreachable, old);
  166. validate_list(old, 0);
  167. validate_list(&unreachable, PREV_MASK_COLLECTING);
  168. /* Call tp_finalize on objects which have one. */
  169. // 执行那些具有的__del__方法的对象。
  170. finalize_garbage(&unreachable);
  171. // 最后,进行进行对垃圾的清除。
  172. if (check_garbage(&unreachable)) { // clear PREV_MASK_COLLECTING here
  173. gc_list_merge(&unreachable, old);
  174. }
  175. else {
  176. /* Call tp_clear on objects in the unreachable set. This will cause
  177. * the reference cycles to be broken. It may also cause some objects
  178. * in finalizers to be freed.
  179. */
  180. m += gc_list_size(&unreachable);
  181. delete_garbage(state, &unreachable, old);
  182. }
  183. /* Collect statistics on uncollectable objects found and print
  184. * debugging information. */
  185. for (gc = GC_NEXT(&finalizers); gc != &finalizers; gc = GC_NEXT(gc)) {
  186. n++;
  187. if (state->debug & DEBUG_UNCOLLECTABLE)
  188. debug_cycle("uncollectable", FROM_GC(gc));
  189. }
  190. if (state->debug & DEBUG_STATS) {
  191. double d = _PyTime_AsSecondsDouble(_PyTime_GetMonotonicClock() - t1);
  192. PySys_WriteStderr(
  193. "gc: done, %" PY_FORMAT_SIZE_T "d unreachable, "
  194. "%" PY_FORMAT_SIZE_T "d uncollectable, %.4fs elapsed\n",
  195. n+m, n, d);
  196. }
  197. /* Append instances in the uncollectable set to a Python
  198. * reachable list of garbage. The programmer has to deal with
  199. * this if they insist on creating this type of structure.
  200. */
  201. // 执行完 __del__没有,不应该被删除的对象,再重新加入到可达链表中。
  202. handle_legacy_finalizers(state, &finalizers, old);
  203. validate_list(old, 0);
  204. /* Clear free list only during the collection of the highest
  205. * generation */
  206. if (generation == NUM_GENERATIONS-1) {
  207. clear_freelists();
  208. }
  209. ...
  210. return n+m;
  211. }

2.6.2 引用

  1. v1 = [11,22,33]
  2. v2 = v1

当对对象进行引用时候,内部引用计数器+1,原理同上。

2.6.3 销毁

  1. v1 = [11,22,33]
  2. del v1

对列表对象进行销毁时,本质上就会执行引用计数器-1(同上),但当引用计数器为0时候,会执行list对象的tp_dealloc,即:

  1. // Object/listobject.c
  2. PyTypeObject PyList_Type = {
  3. PyVarObject_HEAD_INIT(&PyType_Type, 0)
  4. "list",
  5. sizeof(PyListObject),
  6. 0,
  7. (destructor)list_dealloc, /* tp_dealloc */
  8. ...
  9. PyObject_GC_Del, /* tp_free */
  10. };
  11. /* Empty list reuse scheme to save calls to malloc and free */
  12. #ifndef PyList_MAXFREELIST
  13. #define PyList_MAXFREELIST 80
  14. #endif
  15. static PyListObject *free_list[PyList_MAXFREELIST];
  16. static int numfree = 0;
  17. static void
  18. list_dealloc(PyListObject *op)
  19. {
  20. Py_ssize_t i;
  21. // 从分代回收的的代中移除
  22. PyObject_GC_UnTrack(op);
  23. Py_TRASHCAN_BEGIN(op, list_dealloc)
  24. if (op->ob_item != NULL) {
  25. /* Do it backwards, for Christian Tismer.
  26. There‘s a simple test case where somehow this reduces
  27. thrashing when a *very* large list is created and
  28. immediately deleted. */
  29. i = Py_SIZE(op);
  30. while (--i >= 0) {
  31. Py_XDECREF(op->ob_item[i]);
  32. }
  33. PyMem_FREE(op->ob_item);
  34. }
  35. if (numfree < PyList_MAXFREELIST && PyList_CheckExact(op))
  36. // free_list中还么有占满80,不销毁并缓冲在free_list中
  37. free_list[numfree++] = op;
  38. else
  39. // 销毁并在refchain中移除
  40. Py_TYPE(op)->tp_free((PyObject *)op);
  41. Py_TRASHCAN_END
  42. }

2.7 tuple类型

2.7.1 创建

  1. v = (11,22,33)

当创建元组时候,会执行如下源码:

  1. // Objects/tupleobject.c
  2. #define PyTuple_MAXSAVESIZE 20 /* Largest tuple to save on free list */
  3. #define PyTuple_MAXFREELIST 2000 /* Maximum number of tuples of each size to save */
  4. static PyTupleObject *free_list[PyTuple_MAXSAVESIZE]; // free_list[20] = {链表、链表..}
  5. static int numfree[PyTuple_MAXSAVESIZE]; // numfree[2000]表示每个链表的长度
  6. PyObject *
  7. PyTuple_New(Py_ssize_t size)
  8. {
  9. PyTupleObject *op;
  10. ...
  11. // free_list第0个元素存储的是空元祖
  12. if (size == 0 && free_list[0]) {
  13. op = free_list[0];
  14. Py_INCREF(op);
  15. return (PyObject *) op;
  16. }
  17. // 有缓存的tuple对象,则从free_list中获取
  18. if (size < PyTuple_MAXSAVESIZE && (op = free_list[size]) != NULL) {
  19. // 获取对象并初始化
  20. free_list[size] = (PyTupleObject *) op->ob_item[0];
  21. numfree[size]--;
  22. Py_SIZE(op) = size;
  23. Py_TYPE(op) = &PyTuple_Type;
  24. // 对象加入到refchain链表。
  25. _Py_NewReference((PyObject *)op);
  26. }
  27. else
  28. {
  29. ..
  30. // 没有缓存数据,则创建对象
  31. op = PyObject_GC_NewVar(PyTupleObject, &PyTuple_Type, size);
  32. if (op == NULL)
  33. return NULL;
  34. }
  35. for (i=0; i < size; i++)
  36. op->ob_item[i] = NULL;
  37. if (size == 0) {
  38. free_list[0] = op;
  39. ++numfree[0];
  40. Py_INCREF(op); /* extra INCREF so that this is never freed */
  41. }
  42. // 对象加入到分代的链表。
  43. _PyObject_GC_TRACK(op);
  44. return (PyObject *) op;
  45. }
  1. // Includes/objimpl.h
  2. #define PyObject_GC_NewVar(type, typeobj, n) \
  3. ( (type *) _PyObject_GC_NewVar((typeobj), (n)) )
  1. Objects/gcmodules.c
  2. PyVarObject *
  3. _PyObject_GC_NewVar(PyTypeObject *tp, Py_ssize_t nitems)
  4. {
  5. size_t size;
  6. PyVarObject *op;
  7. if (nitems < 0) {
  8. PyErr_BadInternalCall();
  9. return NULL;
  10. }
  11. size = _PyObject_VAR_SIZE(tp, nitems);
  12. // 开内存 & 分代 & 超过阈值则垃圾回收(流程同上述 列表过程)
  13. op = (PyVarObject *) _PyObject_GC_Malloc(size);
  14. if (op != NULL)
  15. op = PyObject_INIT_VAR(op, tp, nitems);
  16. return op;
  17. }

2.7.2 引用

  1. v1 = (11,22,33)
  2. v2 = v1

引用时会触发引用计数器 + 1,具体流程同上。

2.7.3 销毁

  1. v = (11,22,33)
  2. del v

销毁对象时候,执行引用计数器-1,如果计数器减为0,则触发tuple类型的tp_dealloc,详细如下:

  1. PyTypeObject PyTuple_Type = {
  2. PyVarObject_HEAD_INIT(&PyType_Type, 0)
  3. "tuple",
  4. sizeof(PyTupleObject) - sizeof(PyObject *),
  5. sizeof(PyObject *),
  6. (destructor)tupledealloc, /* tp_dealloc */
  7. ...
  8. PyObject_GC_Del, /* tp_free */
  9. };
  10. static void
  11. tupledealloc(PyTupleObject *op)
  12. {
  13. Py_ssize_t i;
  14. Py_ssize_t len = Py_SIZE(op);
  15. // 从分代的链表中移除
  16. PyObject_GC_UnTrack(op);
  17. Py_TRASHCAN_BEGIN(op, tupledealloc)
  18. if (len > 0) {
  19. i = len;
  20. while (--i >= 0)
  21. Py_XDECREF(op->ob_item[i]);
  22. // 缓存到free_list中
  23. if (len < PyTuple_MAXSAVESIZE && numfree[len] < PyTuple_MAXFREELIST &&
  24. Py_TYPE(op) == &PyTuple_Type)
  25. {
  26. op->ob_item[0] = (PyObject *) free_list[len];
  27. numfree[len]++;
  28. free_list[len] = op;
  29. // 结束
  30. goto done; /* return */
  31. }
  32. }
  33. // 不缓存,则直接销毁对象并在refchain链表中移除。
  34. Py_TYPE(op)->tp_free((PyObject *)op);
  35. done:
  36. Py_TRASHCAN_END
  37. }

2.8 dict类型

2.8.1 创建

  1. v = {"name":"武沛齐","age":18}

当创建一个字典对象时,Python底层会执行如下源码:

  1. #define PyDict_MAXFREELIST 80
  2. // 缓存dict对象的free_list
  3. static PyDictObject *free_list[PyDict_MAXFREELIST];
  4. static int numfree = 0;
  5. PyObject *
  6. PyDict_New(void)
  7. {
  8. dictkeys_incref(Py_EMPTY_KEYS);
  9. return new_dict(Py_EMPTY_KEYS, empty_values);
  10. }
  11. /* Consumes a reference to the keys object */
  12. static PyObject *
  13. new_dict(PyDictKeysObject *keys, PyObject **values)
  14. {
  15. PyDictObject *mp;
  16. assert(keys != NULL);
  17. // 如果有缓存,则从缓存区获取一个对象
  18. if (numfree) {
  19. mp = free_list[--numfree];
  20. assert (mp != NULL);
  21. assert (Py_TYPE(mp) == &PyDict_Type);
  22. _Py_NewReference((PyObject *)mp);
  23. }
  24. else {
  25. // 没有缓存,则去创建字典对象。(源码流程同list类型)
  26. mp = PyObject_GC_New(PyDictObject, &PyDict_Type);
  27. if (mp == NULL) {
  28. dictkeys_decref(keys);
  29. if (values != empty_values) {
  30. free_values(values);
  31. }
  32. return NULL;
  33. }
  34. }
  35. mp->ma_keys = keys;
  36. mp->ma_values = values;
  37. mp->ma_used = 0;
  38. mp->ma_version_tag = DICT_NEXT_VERSION();
  39. ASSERT_CONSISTENT(mp);
  40. return (PyObject *)mp;
  41. }

2.8.2 引用

  1. v1 = {"name":"武沛齐","age":18}
  2. v2 = v1

出现引用,则应用计数器+1(同上)。

2.8.3 销毁

  1. v1 = {"name":"武沛齐","age":18}
  2. del v1

销毁一个对象时候,引用计数器-1,当减到0时候,则触发dict类型的tp_dealloc,源码如下:

    1. // Object/dictobject.c
    2. PyTypeObject PyDict_Type = {
    3. PyVarObject_HEAD_INIT(&PyType_Type, 0)
    4. "dict",
    5. sizeof(PyDictObject),
    6. 0,
    7. (destructor)dict_dealloc, /* tp_dealloc */
    8. ...
    9. PyObject_GC_Del, /* tp_free */
    10. };
    11. static void
    12. dict_dealloc(PyDictObject *mp)
    13. {
    14. PyObject **values = mp->ma_values;
    15. PyDictKeysObject *keys = mp->ma_keys;
    16. Py_ssize_t i, n;
    17. // 从分代链表中移除
    18. PyObject_GC_UnTrack(mp);
    19. Py_TRASHCAN_BEGIN(mp, dict_dealloc)
    20. ...
    21. // 缓存区为满,则缓存
    22. if (numfree < PyDict_MAXFREELIST && Py_TYPE(mp) == &PyDict_Type)
    23. free_list[numfree++] = mp;
    24. else
    25. // 已满则销毁,并在refchain中移除。
    26. Py_TYPE(mp)->tp_free((PyObject *)mp);
    27. Py_TRASHCAN_END
    28. }

python垃圾回收机制的原理

标签:字符串   集合   void   har   car   构造   并且   dig   对象销毁   

原文地址:https://www.cnblogs.com/Gaimo/p/12741283.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!