Python垃圾回收机制
python垃圾回收机制和内存管理机制
引用计数为主, 标记清除和分代回收为辅+缓存机制
1.引用计数器
1.1 环状的双线链表 refchain
在python程序中创建的任何对象都会存在refchain双向链表中
name = 'ds'
age = 18
hobby = ['篮球','美女']
# str
内部会创建一个结构体数据 [上一个对象(指针),下一个对象(指针),类型,引用计数]
# name = 'ds'
new = name new 不会重新创建一个ds的数据, 是指向ds这个数据,引用计数则加+1
# float 多一个val , 存储数据具体值
内部会创建一个结构体数据 [上一个对象(指针),下一个对象(指针),类型,引用计数,val=18]
age = 18
# list , 多存一个items存放的元素容器 和元素个数
内部会创建一个结构体数据 [上一个对象(指针),下一个对象(指针),类型,引用计数,items=元素,元素个数]
hobby = ['篮球','美女']
在C源码中如何体现每个对象中有相同的值 : PyObject结构体(4个值)
有多个元素组成的对象:PyObject结构体(4个值)+ob_size(元素个数)
# C 源码.
PyObject_VAR_HEAD
// 宏定义 , 包含上一个,下一个,用户构建双向链表,(放到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;
1.2 类型封装的结构
-
float 类型
typedef struct { PyObject_HEAD double ob_fval; // 存放 具体数据 } PyFloatObject; // 举例子 data = 3.14 _ob_next : refchain 双向链表中的上一个对象 _ob_prev : refchain 双线链表中的下一个对象 ob_refcnt : 1 // 引用计数 ob_type : float //类型 ob_fval : 3.14 -
int 类型
struct _longobject { PyObject_VAR_HEAD digit ob_digit[1]; }; -
list 类型
typedef struct { PyObject_VAR_HEAD /* Vector of pointers to list elements. list[0] is ob_item[0], etc. */ PyObject **ob_item; // 元素列表 /* ob_item contains space for 'allocated' elements. The number * currently in use is ob_size. * Invariants: * 0 <= ob_size <= allocated * len(list) == ob_size * ob_item == NULL implies ob_size == allocated == 0 * list.sort() temporarily sets allocated to -1 to detect mutations. * * Items must normally not be NULL, except during construction when * the list is not yet visible outside the function that builds it. */ Py_ssize_t allocated; // 元素个数 } PyListObject; -
tuple 类型
typedef struct { PyObject_VAR_HEAD PyObject *ob_item[1]; /* ob_item contains space for 'ob_size' elements. * Items must normally not be NULL, except during construction when * the tuple is not yet visible outside the function that builds it. */ } PyTupleObject; -
dict 类型
typedef struct { PyObject_HEAD /* Number of items in the dictionary */ Py_ssize_t ma_used; /* Dictionary version: globally unique, value change each time the dictionary is modified */ uint64_t ma_version_tag; PyDictKeysObject *ma_keys; /* If ma_values is NULL, the table is "combined": keys and values are stored in ma_keys. If ma_values is not NULL, the table is splitted: keys are stored in ma_keys and values are stored in ma_values */ PyObject **ma_values; } PyDictObject;
1.3 引用计数器
v1 = 3.14
v2 = 1
v3 = (1,2,3)
在python程序运行过程中,会根据数据类型的不同找到其对应的结构体. 根据结构体中的字段来创建相关的数据,然后将对象添加到refchain双线链表中
在C源码中,有两个关键的结构体: PyObject , PyVarObject
每个对象中都有ob_refcnt, 这就是引用计数器.默认值是1,当其他变量引用对象时,引用计数器就会发生变化
-
引用
a = 999 b = a # 999 对象 的引用计数器就会 +1 -
删除
a = 999 b = a del b # 1. b变量删除, 2. b对应的对象的引用计数器 -1 del a # 1. a变量删除, 2. a对应的对象的引用计数器 -1 , 就是 0 # 当一个对象的引用计数器 为 0 时, 意味着没有再使用这个变量, 这个变量就是垃圾. 垃圾就要进行垃圾回收机制 # 垃圾回收,两件事 : 1. 对象从refchain双线链表中移除 2. 将对象销毁,内存归还.
1.4 循环引用问题
v1 = [1,2,3]
v2 = [4,5,6]
v1.append(v2) // v2 追加到v1列表中, v2的引用计数器+1,最终为2
v2.append(v1) // v1 追加到v2列表中, v1的引用计数器+1,最终为2
del v1 // 删除v1 变量,引用计数器-1
del v2 // 删除v2 变量,引用计数器-1
# 问题:
此时, v1和v2的引用计数器还是1,不是0,所以不会被当做垃圾给回收?
`标记清除` : 解决这样的问题
2.标记清除
目的: 为了解决引用计数器循环引用的不足
实现:在python的底层,在维护一个链表,链表中专门存放那些可能存在循环引用的对象(list/set/tuple)
在Python内部某种情况下触发,会扫描可能存在循环引用的链表中的每一个元素,检查是否有循环引用,如果有则让双方引用计数器 -1 ;如果是0则垃圾回收
3.分代回收
将肯能存在循环引用的对象维护成3个链表
- 0 代 : 0代中对象个数达到700个扫描一次
- 1 代 : 0代扫描10次,则 1代扫描一次
- 2 代 : 1代扫描10次,则 2代扫描一次
4.小结
在python中维护了一个refchain的双向环状链表, 这个链表中存储了程序中创建的所有对象,每种类型的对象中都有一个 ob_refcnt引用计数器的值,引用个数+1 , -1 , 最后当引用计数器变为0时,会进行垃圾回收(对象销毁,refchain中移除)
但是,在python中对于那些可以有多个元素组成的对象,可能会存在循环引用的问题,为了解决这个问题python又引用了标记清除和分代回收
,在python内部维护了4个链表:
- refchain
- 2代 10次
- 1代 10次
- 0代 700个对象
在python源码内部,当达到各自的阈值时,就会触发扫描链表进行标记清除的动作(如果有循环引用,则各自-1引用)
但是:源码内部在上述的流程中提出了优化机制缓存
5.python缓存
5.1 小数据池(int , str字符串)
为了避免重复的创建和销毁一些常见对象,维护了一个池.
v1 = 7
v2 = 9
v3 = 9
# python 为了节省资源
1. 在启动解释器的时候, 内部会创建`-5,-4,....256`范围数值
2. 在内部 v1 =7 不会创建新的新对象,也不会开辟内存.直接上池中去取数据
# print(id(v2),id(v3))
3.超过 -5 ... 256 这个范围,重新开辟内存,创建对象
5.2 free_list(float:100/tuple:20/dict:80/list:80)
当引用计数器为0时,按理说是要进行垃圾回收. python内部不会去回收,而是将对象添加到free_list这个链表中作为缓存. 以后再去创建对象时,不会再去开辟内存,直接使用free_list中的数据
v1 = 3.14 # 1. 开辟内存,创建对象,引用计数器为1,并添加到refchain链表中
del v1 # 2. 从refchain中移除 , 将这个对象添加到free_list中,如果free_list链表缓存满了,再进行垃圾回收
v9 = 999.99 # 3. 不会重新开辟内存,直接去free_list中获取一个float类型的数据,对象内部数据初始化,再放到refchain链表中
