一、python源码
1.准备源码
下载Python源码：https://www.python.org/ftp/python/3.8.0/Python-3.8.0.tgz
解压得到文件夹：
我们主要关注Include中的".h"文件以及Objects目录中的".c"文件。
我们从Include和Objects中的文件类型就可以看出Python解释器是C语言编写的。
2.object.h
在Include文件夹中，全部都是".h"文件。
这些C语言头文件中主要存放着宏、函数声明、结构体声明、全局变量等。
我们在Python中所有的类都继承自Object，所以在这个C语言的object.h中，我们可以看看是如何实现的。
我们首先看object.h文件内容（小部分）：
#define _PyObject_HEAD_EXTRA struct _object *_ob_next; struct _object *_ob_prev;
typedef struct _object {
// 维护双向链表refchain
_PyObject_HEAD_EXTRA
// 引用计数
Py_ssize_t ob_refcnt;
// 数据的类型
struct _typeobject *ob_type;
} PyObject;
typedef struct {
PyObject ob_base;
// 数据类型为多元素时，维护一个容量个数
Py_ssize_t ob_size; /* Number of items in variable part */
} PyVarObject;
我们可以从上面的源码中看到，两个结构体PyObject和PyVarObject，区别是PyVarObject多一个ob_size属性，这个属性代表的是元素的个数（例如list、dict中元素的个数）。
所以，这两个结构体，分别对应不同类型的数据的头（Python中任何数据的定义，都会有这个头）：
PyObject：float
PyVarObject：list、dict、tuple、set、int、str、bool
因为Python中的int是不限制长度的，所以底层实现是用的str，所以int也属于PyVarObject阵营。Python中的bool实际上是0和1，所以也是int，也属于PyVarObject阵营。
3.floatobject.h
typedef struct {
PyObject_HEAD
double ob_fval;
} PyFloatObject;
我们以float类型为例，可以看到创建一个float类型的数据，实际上是创建了一个PyFloatObject结构体的实例。
PyFloatObject结构体中包含了一个PyObject_HEAD（这就是object.h中的PyObject），以及一个double ob_fval，这个double变量就是我们存放的值。
我们以Python中的实际操作，来看源码中的过程：
1）python中定义变量v = 0.3：
源码流程：
a.开辟内存（内存大小，是sizeof(PyFloatObject)）
b.初始化
ob_fval=0.3
ob_type=float
ob_refcnt=1
c.将对象加入双向链表refchain中
2）python执行操作name=v：
源码流程：
ob_refcnt+=1
3）python执行操作del v：
源码流程：
ob_refcnt-=1
4）python执行
def func(arg):
print(arg)
func(name)
源码流程：
执行时开辟栈：ob_refcnt+=1
结束时销毁栈：ob_refcnt-=1
5）python执行del name：
源码流程：
ob_refcnt-=1
在这几次操作中，每次进行ob_refcnt-=1的时候都会判断ob_refcnt是否等于0。如果是0，这将其归为垃圾，按理说GC回收器应该将其回收，请看第二节。
二、缓存机制
在第一节中，如果float变量的引用都被删除，引用计数为0以后，按理说GC回收器应该对其进行回收。
1.free_list缓存链表
但编译器认为，用户经常都要定义float类型的变量，所以他将该PyFloatObject对象从refchain链表中拿出来，并且放到另一个单向链表中，这个单向链表就是缓存（叫free_list）。
我们做个验证：
>>> v = 8.9 >>> name = v >>> del v >>> id(name) 1706304905888 >>> del name >>> xx = 9.0 >>> id(xx) 1706304905888 >>>
可以看到，name的id为1706304905888，删除name后，由创建了一个float变量xx，结果xx的id还是为170630490588。这就验证了缓存的机制。
为什么要使用缓存（free_list）？
因为回收内存空间和开辟内存空间都要消耗时间，所以，如果将空间放到缓存中，有新的float变量被定义的话，直接从缓存中拿到地址，重新进行一次初始化，并将新的值赋给ob_fval即可。
2.free_list最大长度
注意，这里的单向链表（free_list）只是针对PyFloatObject类型的。而且这个链表有最大长度100。可以在floatobject.c中看到相关定义：
#ifndef PyFloat_MAXFREELIST // 定义free_list的最大长度 #define PyFloat_MAXFREELIST 100 #endif // 用numfree来表示当前free_list有多长 static int numfree = 0; // free_list指针 static PyFloatObject *free_list = NULL;
例如同时有1000个float变量的引用计数变为0，则归入free_list的只有100个，其余900个可能会被回收。
在float中，free_list的最大长度是100，而在其他的数据类型中，最大长度可能不一样。
例如list的free_list的最大长度为80：
#ifndef PyList_MAXFREELIST #define PyList_MAXFREELIST 80 #endif static PyListObject *free_list[PyList_MAXFREELIST]; static int numfree = 0;
dict也为80：
#ifndef PyDict_MAXFREELIST #define PyDict_MAXFREELIST 80 #endif static PyDictObject *free_list[PyDict_MAXFREELIST]; static int numfree = 0; static PyDictKeysObject *keys_free_list[PyDict_MAXFREELIST]; static int numfreekeys = 0;
3.其他优化机制
也不是所有的数据类型都使用free_list缓存机制，例如int用的是小数据池进行优化：
#ifndef NSMALLPOSINTS #define NSMALLPOSINTS 257 #endif #ifndef NSMALLNEGINTS #define NSMALLNEGINTS 5 #endif
三、垃圾回收机制
Python的GC主要遵循以下原则：
引用计数器为主，标记清除和分代回收为辅。
1.引用计数器（同上，略）
2.循环引用
循环引用一般发生在列表、字典、对象等容器类对象，他们之间可以互相嵌套，例如：
a = [1, 2] b = [4, 5] # b的引用计数会加1，变为2 a.append(b) # a的引用计数变为0 del a # b的引用计数变为1，但是已经无法访问b，所以就形成了内存泄漏 del b
在这种情况下， 内存发生了泄漏，就要利用标记清除来解决循环引用的问题。
2.标记清除
针对那些容器类的对象，在Python中会将他们单独放到一个双向链表（非refchain）中，做定期扫描。
参考：https://www.cnblogs.com/saolv/p/8411993.html
#第一组循环引用# a = [1,2] b = [3,4] a.append(b) b.append(a) del a ## #第二组循环引用# c = [4,5] d = [5,6] c.append(d) d.append(c) del c del d #至此，原a和原c和原d所引用的对象的引用计数都为1,b所引用的对象的引用计数为2， e [7,8] del e
现在说明一下标记清除:代码运行到上面这块了，此时，我们的本意是想清除掉c和d和e所引用的对象，而保留a和b所引用的对象。但是c和d所引用对象的引用计数都是非零，原来的简单的方法只能清除掉e，c和d所引用对象目前还在内存中。
假设，此时我们预先设定的周期时间到了，此时该标记清除大显身手了。他的任务就是，在a,b,c,d四个可变对象中，找出真正需要清理的c和d，而保留a和b。
首先，他先划分出两拨，一拨叫root object(存活组)，一拨叫unreachable(死亡组)。然后，他把各个对象的引用计数复制出来，对这个副本进行引用环的摘除。
环的摘除：假设两个对象为A、B，我们从A出发，因为它有一个对B的引用，则将B的引用计数减1；然后顺着引用达到B，因为B有一个对A的引用，同样将A的引用减1，这样，就完成了循环引用对象间环摘除。
摘除完毕，此时a的引用计数的副本是0，b的引用计数的副本是1，c和d的引用计数的副本都是0。那么先把副本为非0的放到存活组，副本为0的打入死亡组。如果就这样结束的话，就错杀了a了，因为b还要用，我们把a所引用的对象在内存中清除了b还能用吗？显然还得在审一遍，别把无辜的人也给杀了，于是他就在存活组里，对每个对象都分析一遍，由于目前存活组只有b，那么他只对b分析，因为b要存活，所以b里的元素也要存活，于是在b中就发现了原a所指向的对象，于是就把他从死亡组中解救出来。至此，进过了一审和二审，最终把所有的任然在死亡组中的对象通通杀掉，而root object继续存活。b所指向的对象引用计数任然是2，原a所指向的对象的引用计数仍然是1
扫描后存活组的对象，将放到另外一个链表中去，一共有3个这样的链表，代表3代。
3.分代回收
分代回收就是指维护容器类对象的三个链表，3个链表对应三层。对最底层的链表扫描10次，才对上层的链表扫描一次。
这其实是为了节省性能，尽量少扫描对象。
认为没有问题经常使用的对象放入上一层，减少扫描次数。
所以，在Python的内存管理中，一共维护着4个链表，其中一个链表refchain用来管理一般的数据类型，例如float等。而另外3个链表组成分代，管理容器类数据类型。
参考博客：https://www.cnblogs.com/wupeiqi/articles/11507404.html
原文地址：https://www.cnblogs.com/leokale-zz/p/12113559.html