Python内存管理以及垃圾回收机制

介绍

本文主要介绍了Python的内存管理机制、垃圾回收原理以及缓存机制三个部分
本文主要参考了:
bilibili视频：【基于C语言源码剖析】python垃圾回收和内存管理
pythonav：Python内存管理和垃圾回收机制
简书博客：python内存管理机制
博客：Python的内存管理机制
脚本之家：Python 内存管理机制全面分析

由于python中万物皆对象，所以python的存储问题是对象的存储问题。

内存管理机制

内存金字塔

图片来自于：Python的内存管理机制

-1，-2层主要有操作系统进行操作；
第零层Layer0是C中的malloc，free等内存分配和释放函数进行操作；
第一层Layer1的仅仅是对malloc的简单包装, raw memory，目的是为了兼容各个操作系统，因为不同的操作系统调用malloc的时候可能会有不同的行为结果；
第二层Layer2是内存管理机制的核心，其中gc就是在这一层发挥至关重要的作用；
第三层Layer3是对象缓冲池，如Python对一些对象的直接操作，包括int，list等。

抛开-1和-2层，我们可以说Python的内存管理总共分为4层(Layer0-3)
特别地，

如果请求分配的内存在1~256字节之间就使用自己的内存管理系统（内存池），否则直接使用 malloc。
调用 malloc 分配内存时，每次会分配一块大小为256k的大块内存。
经由内存池登记的内存到最后还是会回收到内存池，并不会调用 C 的 free 释放掉，以便下次使用。

也就是说，Python分配内存的时候又分为大内存和小内存，大内存以256字节为界限，对于大内存使用Malloc进行分配，而对于小内存则使用内存池进行分配，由于小内存的分配和释放是频繁的，因此内存池的使用大大提高了Python的执行效率。

环状双向链表（refchain）

在Python的C源码中有一个名为refchain的环状双向链表，Python程序中一旦创建对象都会把这个对象添加到refchain这个链表中。也就是说它保存着当前Python程序中所有的对象。

顾名思义，环状双向链表是一种首尾相连的双向链表数据结构。
双向链表中每个元素中存在两个指针，一个指向上一个元素的地址，一个指向下一个元素的地址。
这样就可以实现从环状双向链表中任意一个元素开始查找到其他任意元素。
在Python程序中创建的全部对象都会保存在这个链表中。

引用计数

在refchain中的所有对象内部都有一个ob_refcnt用来保存当前对象的引用计数器，顾名思义就是自己被引用的次数。
当对象被引用的时候，不会在内存中重复创建数据，而是引用计数器+1 。
当对象被销毁的时候，会让引用计数器-1。
如果引用计数器为0，则将对象从refchain链表中摘除，同时垃圾回收机制会将此对象占用的内存收回。

引用+1的情况：

对象被创建：a = ‘abc’
对象被引用：b = a
对象作为其他对象的一个元素：c = [1,2,a]
对象被作为参数传递给函数：f(a)

引用-1的情况：

变量被删除：del a or del b
变量引用了其他对象：b = c or a = c
在其他的引用对象中被删除（移除）：c.remove(a)
引用对象本身被销毁：del c
变量离开了所在的作用域（函数调用结束）：比如f(a)结束时，传入参数a的引用次数-1

查看变量的引用次数

import sys
a = 666
print(sys.getrefcount(a))  # 2
b = a
print(sys.getrefcount(a))  # 3
c = [1, 2, a]
print(sys.getrefcount(a))  # 4
del c
print(sys.getrefcount(a))  # 3
del a
print(sys.getrefcount(b))  # 2
del b
# 由于已经没有了变量，无法使用sys.getrefcount函数进行计数
# 但我们可知存666这个整型对象的引用次数为0了

注意：
sys.getrefcount函数返回的计数总是比实际的引用次数多1，这是因为这里面包含了调用此函数的临时计数。
简单来说就是：sys.getrefcount本身也引用了变量，导致对象的计数被+1

当我们测试整型1时，会发现返回的引用次数是一个奇怪的数字。
这是因为Python程序内部很多地方都在引用这个数字。

垃圾回收机制

引用计数

引用计数也是一种垃圾回收机制，而且也是一种最直观，最简单的垃圾收集技术。
当python某个对象的引用计数降为 0 时，说明没有任何引用指向该对象，该对象就成为要被回收的垃圾了。
优点：简单实时性。
缺点：维护引用计数消耗资源，且无法解决循环引用。

标记清除

创建特殊链表专门用于保存 列表、元组、字典、集合、自定义类等对象，之后再去检查这个链表中的对象是否存在循环引用，如果存在则让双方的引用计数器均 - 1 。
缺点：清除非活动的对象前它必须顺序扫描整个堆内存，哪怕只剩下小部分活动对象也要扫描所有对象。

简单来说，标记清除就是为了解决引用计数无法解决的循环引用问题
那什么是循环引用呢？
举pythonav中的一个例子

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

对于上述代码会发现，执行del操作之后，没有变量再会去使用那两个列表对象，但由于循环引用的问题，他们的引用计数器不为0。所以他们的状态：永远不会被使用、也不会被销毁。项目中如果这种代码太多，就会导致内存一直被消耗，直到内存被耗尽，程序崩溃。
为了解决循环引用的问题，引入了标记清除技术，专门针对那些可能存在循环引用的对象进行特殊处理，可能存在循环应用的类型有：列表、元组、字典、集合、自定义类等那些能进行数据嵌套的类型。

分代回收

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

简单来说，分代回收就是为了提升标记清除的效率
三代有着不同的阈值来触发是否扫描整个链表
对于第一代：判断链表中的元素数量是否超过一个固定的阈值（700），如果是则进行一次第一代扫描检查
对于第二代：判断第一代扫描的次数是否超过一个固定的阈值（10），如果是则进行一次第二代扫描检查
对于第三代：判断第二代扫描的次数是否超过一个固定的阈值（10），如果是则进行一次第三代扫描检查

每次扫描一方面是销毁引用为0的对象，一方面检查循环引用的情况，如果有就将引用次数-1
对于具体的扫描过程可以参考pythonav
本文为了完整性，搬用了pythonav中的具体步骤
（注意，pythonav说的是0/1/2三代，而我觉得使用1/2/3三代更符合理解）

当1代大于阈值后，底层不是直接扫描1代，而是先判断3、2是否也超过了阈值。
如果3、2代未达到阈值，则扫描1代，并让1代的扫描次数 + 1 。
如果3代已达到阈值，则将3、2、1三个链表拼接起来进行全扫描，并将3、2、1代的扫描次数重置为0。
如果2代已达到阈值，则讲2、1两个链表拼接起来进行扫描，并将所有2、1代的扫描次数重置为0。

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

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

缓存机制

因为内存申请和销毁一般比较耗时，Python有两大类缓存机制来避免频繁的内存申请和销毁从而提升效率。

池

针对一些常见的对象，Python内部维护了一个池，来避免重复创建和销毁常见的对象。
在解释器中程序一开始就默认创建了一些常见的对象放在池中，当程序中用到这些对象时，只需要从池中获取就行，即引用次数+1，而不需要重新一个新的对象，也不需要开辟新的内存。
此外，在程序过程中池中的对象不会被销毁，除非程序结束。

放在池中的对象有：

-5到256的整数
所有的ascii字符
等等

举例：

 a = 7  # 不会创建对象也不会开辟内存，直接从池中获取；140705788798960
 b = 8  # 不会创建对象也不会开辟内存，直接从池中获取；140705788798992
 c = 9  # 不会创建对象也不会开辟内存，直接从池中获取；140705788799024
 d = 9  # 不会创建对象也不会开辟内存，直接从池中获取；140705788799024
 e = 666  # 会创建对象也会开辟新内存；2606393385424
 f = 666  # 会创建对象也会开辟新内存；2606393385680
 print(id(a))  # 查看变量的地址

我们可以发现，变量c和d都是代表的整型对象9，但两者的地址是完全一样（140705788799024），说明变量c和d都是从池中获取的，而不是新建的对象。
相反，对于变量e和f都是代表的整型对象666，但两者的地址不一样，说明两者都是各自重新新建的对象以及开辟的新内存

free_list

当一个对象的引用计数为0时，程序内部本应该立即将内存销毁，但内部并没有直接销毁。
而是将对象添加到free_list链表中当做缓存，以后再去创建新对象时，不在重新开辟内存，而是直接使用free_list。
Python中不同的数据类型使用的free_list也不同，比如小的整数型就不使用free_list，而是使用池，float和list里面free_list缓存的元素个数也不同。

举例：

v1 = 3.14      # 开辟内存来存储float对象，并将对象添加到refchain链表。
print(id(v1))  # 内存地址：4436033488
del v1         # 引用计数器-1，如果为0则在rechain链表中移除，不销毁对象，而是将对象添加到float的free_list.
v2 = 9.999     # 优先去free_list中获取对象，并重置为9.999，如果free_list为空才重新开辟内存。
print(id(v2))  # 内存地址：4436033488
# 注意：引用计数器为0时，会先判断free_list中缓存个数是否满了，
# 未满则将对象缓存，已满则直接将对象销毁。

对于不同的数据类型，free_list也有不同的区别

int类型

int类型，不是基于free_list，而是维护一个small_ints链表保存常见数据（小数据池），小数据池范围：-5 <= value <= 256。即：重复使用这个范围的整数时，不会重新开辟内存。

注意：在解释器启动时候-5~256就已经被加入到small_ints链表中且引用计数器初始化为1，代码中使用的值时直接去small_ints中拿来用并将引用计数器+1即可。另外，small_ints中的数据引用计数器永远不会为0（初始化时就设置为1了），所以也不会被销毁。

float类型

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

注意：引用计数器为0时，会先判断free_list中缓存个数是否满了，未满则将对象缓存，已满则直接将对象销毁。

str类型

str类型，维护unicode_latin1[256]链表，内部将所有的ascii字符缓存起来，以后使用时就不再反复创建。

除此之外，Python内部还对字符串做了驻留机制，针对那么只含有字母、数字、下划线的字符串（见源码Objects/codeobject.c），如果内存中已存在则不会重新在创建而是使用原来的地址里（不会像free_list那样一直在内存存活，只有内存中有才能被重复利用）。

list类型

list类型，维护的free_list数组最多可缓存80个list对象。

tuple类型

tuple类型，维护一个free_list数组且数组容量20，数组中元素可以是链表且每个链表最多可以容纳2000个元组对象。元组的free_list数组在存储数据时，是按照元组可以容纳的个数为索引找到free_list数组中对应的链表，并添加到链表中。

dict类型

dict类型，维护的free_list数组最多可缓存80个dict对象。

总结

在Python中维护了一个名为refchain的环状双向链表，这个链表中存储了Python程序中创建的所有对象。
每种类型的对象中都有一个名为ob_refcnt的引用计数器，它用于计数当前对象被引用的次数，变量被引用一次就+1，删除一次就-1。
当最后引用计数器变为0时，会进行垃圾回收，包含两步，一是将变量从refchain中移除，二是将对象进行销毁即回收占用的内存。

但在Python中对于那些可以有多个元素组成的对象，比如list，dict，tuple等，可能会存在循环引用的问题，这会导致被应该被销毁的对象，引用次数却不为0，从而无法被销毁。为了解决这个问题，Python进一步引入了标记清除机制，通过创建一个新的链表来扫描可能存在循环引用的对象，如果存在则将引用计数-1。

为了优化标记清除，进一步提出了分代回收机制，在refchain的基础上，再另外维护三个链表，这三个代表有着不同的扫描阈值，当达到这个阈值后，将链表进行扫描，销毁对象并检查循环引用。

为了进一步提升效率，避免频繁地进行对象的申请和销毁，Python内部维护了一个池和一个free_list数组。池的做法是预先缓存一些常见的对象，比如-5到256的整型对象，和ascii字符等。当程序中定义一个小的整型对象时，不需要创建，直接从池中获取就行。free_list的做法是将程序本来删除的对象，没有直接销毁而是放在一个名为free_list的数组中。后面当程序中重新创建一个相同类型的对象时，不必新开辟空间而是直接从free_list中获取对象，重新进行初始化并放入refchain中去。

C语言源码解析

我这里展示的源码是从Python官网下载的，下载地址：https://www.python.org/downloads/source/，也可以点击这里直接下载。
下载的版本是3.10.4稳定版本

两个重要的结构体

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

我的理解是：
PyObject结构体主要包含三个部分: 一个是用于构建双向链表的上下指针（pythonav把这里算的两个部分）；一个是引用计数器用于统计该变量的引用次数；一个是记录该变量的数据类型。
PyVarObject结构体在PyObject的基础上多添加了一个数据，用于统计该变量中的元素个数。该结构体用于创建list/set/tuple等由多个元素组成的对象

// Object/object.h
// Line 70
/* Define pointers to support a doubly-linked list of all live heap objects. */
// 宏定义，包含两个指针，一个指向双向链表（refchain）上一个元素的地址，一个指向下一个元素的地址
#define _PyObject_HEAD_EXTRA            \
    struct _object *_ob_next;           \
    struct _object *_ob_prev;

/* PyObject_HEAD defines the initial segment of every PyObject. */
#define PyObject_HEAD                   PyObject ob_base;  // Line 82
#define PyObject_VAR_HEAD      PyVarObject ob_base;        // Line 97

// Line 105
/* Nothing is actually declared to be a PyObject, but every pointer to
 * a Python object can be cast to a PyObject*.  This is inheritance built
 * by hand.  Similarly every pointer to a variable-size Python object can,
 * in addition, be cast to PyVarObject*.
 */
typedef struct _object {
    
    
    _PyObject_HEAD_EXTRA    // 用于构造双向链表
    Py_ssize_t ob_refcnt;   // 引用计数器
    PyTypeObject *ob_type;  // 数据类型
} PyObject;

// Line 115
typedef struct {
    
    
    PyObject ob_base;   // PyObject对象
    Py_ssize_t ob_size; /* Number of items in variable part */ // 元素个数
} PyVarObject;

对于其他每种具体数据类型的定义源码，请参考pythonav
个人觉得写得非常细致了，本文也是从中学习过来的，感谢博主
也建议观看对应的bilibili视频