Python基础之内存管理与垃圾回收机制

引用计数

环状双向链表refchain

在Python程序中创建的任何对象都会放在refchain链表中

name = "featherwit"
age = 18
hobby = ["篮球", "乒乓球"]

在创建对象的时候, Python内部会创建一些数据, 比如:[上一个对象的指针、下一个对象的指针、类型、引用个数、值]

源码

#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;

在C语言源码中, 使用PyObject结构体来体现每个对象都有的相同的属性；

在C语言源码中, 使用PyVarObject结构体来体现多个元素组成的对象: PyObject结构体(4个值) + ob_size

引用计数器

当Python程序运行时, 会根据数据类型的不同找到其对应的数据类型结构体, 根据结构体中的字段来进行创建相关的数据, 然后将对象添加到refchain双向链表中。

在C源码中有两个关键的结构体: PyObject、PyVarObject

每个对象都有ob_refcnt这个属性, 这就是引用计数器, 值默认是1,  当有其他变量引用对象时, 引用计数器就会发生变化。

• 引用

# 创建对象, 并初始化, 引用计数器为1
a = 123
b = a

• 删除引用 

a = 123
b = a
del b  # b变量删除; b对应的对象引用计数器-1
del a  # a变量删除; a对应的对象引用计数器+1

# 当一个对象的引用计数器为0时, 意味着没有人再使用这个对象了, 这个对象就是垃圾, 进行垃圾回收
# 垃圾回收: 1. 将对象从refchain链表移除  2. 将对象销毁, 内存归还

循环引用&交叉感染

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追加到v2中, 则v1对应的[11,22,33]对象的引用计数器加1, 最终为2

del v1   # 引用计数器-1
del v2   # 引用计数器-1

# 这样已经没有变量引用列表对象了, 但是他们的引用计数器为1, 从而销毁，导致内存脏数据

标记清除

目的: 为了解决引用计数器循环引用的不足而产生的方法

实现: 在Python底层再去维护一张链表, 链表中专门放那些可能存在循环引用的对象(列表/元组/字典/集合)

在Python内部的某种情况下, 会去扫描可能存在循环引用的链表中的每个元素, 检查是否有循环引用, 如果有则让双方的引用计数器-1, 如果引用计数器为0则垃圾回收

问题:

• 什么时候扫描?
• 可能存在循环引用的链表扫描代价大, 每次扫描耗时比较久

分代回收

将可能存在循环引用的对象维护成3个链表:

• 0代: 0代中对象个数达到700个扫描一次
• 1代:  0代扫描10次, 则1代扫描一次
• 2代: 1代扫描10次, 则2代扫描一次

Python缓存

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

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

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中缓存个数是否满了，未满则将对象缓存，已满则直接将对象销毁。

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

v1 = 38    # 去小数据池small_ints中获取38整数对象，将对象添加到refchain并让引用计数器+1。
print( id(v1))  #内存地址：4514343712
v2 = 38 # 去小数据池small_ints中获取38整数对象，将refchain中的对象的引用计数器+1。
print( id(v2) ) #内存地址：4514343712

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

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

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

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

v1 = [11,22,33]
print( id(v1) ) # 输出：4517628816
del v1
v2 = ["A","BC"]
print( id(v2) ) # 输出：4517628816

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

v1 = (1,2)
  print( id(v1) )
  del v1  # 因元组的数量为2，所以会把这个对象缓存到free_list[2]的链表中。
  v2 = ("A","B")  # 不会重新开辟内存，而是去free_list[2]对应的链表中拿到一个对象来使用。
  print( id(v2) )

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

v1 = {"k1":123}
print( id(v1) )  # 输出：4515998128
del v1
v2 = {"name":"featherwit","age":18,"gender":"男"}
print( id(v1) ) # 输出：4515998128