Python - 垃圾回收机制

引言：

解释器在执行到定义变量的语法时，会申请内存空间来存放变量的值，而内存的容量是有限的，这就涉及到变量值所占用内存空间的回收问题，当一个变量值没有用了（简称垃圾）就应该将其占用的内存给回收掉，那什么样的变量值是没有用的呢？

单从逻辑层面分析，我们定义变量将变量值存起来的目的是为了以后取出来使用，而取得变量值需要通过其绑定的直接引用（如x=10，10被x直接引用）或间接引用（如l=[x,]，x=10，10被x直接引用，而被容器类型l间接引用），所以当一个变量值不再绑定任何引用时，我们就无法再访问到该变量值了，该变量值自然就是没有用的，就应该被当成一个垃圾回收。

毫无疑问，内存空间的申请与回收都是非常耗费精力的事情，而且存在很大的危险性，稍有不慎就有可能引发内存溢出问题，好在Cpython解释器提供了自动的垃圾回收机制来帮我们解决了这件事。

一：简介

1.什么是垃圾

在python中，会定义一个变量名，然后赋给它变量值，如果这个变量调用结束了，不需要它了，将它删除，但是这时候变量名被删除了，变量值还在，这时候这个变量值就是 垃圾。

2.什么是垃圾回收机制

垃圾回收机制（Garbage Collection）简称GC, 是python解释器自带的一种机制, 专门用来回收不可用的变量值所占用的内存空间。

3.为什么要有垃圾回收机制

程序在运行的过程中会申请内存空间, 而对于一些无用的内存空间如果不及时清理的话会一直占用内存空间, 进而造成内存溢出, 最终导致程序GG。
但是内存管理是一件麻烦事, Python则提供了垃圾回收机制来释放不必要的内存空间。

4.堆区 与 栈区

栈区：

用于存放 变量名与值内存地址的关联关系。

堆区：

用于存放 变量值，也是内存管理回收的地方。

5.查看变量的内存地址

x = 10
y = 20

# id(x) 可以查看变量x的id
print(id(x))        # 140716865820608
print(id(y))        # 140716865820928

# 用hex()把id(x)包起来，可以查看变量x的内存地址
print(hex(id(x)))   # 0x7ffb32cd17c0
print(hex(id(y)))   # 0x7ffb32cd1900

二：引用计数

1.什么是引用计数

Python垃圾回收主要以引用计数为主，分代回收为辅。引用计数法的原理是每个对象维护一个ob_ref，用来记录当前对象被引用的次数，也就是来追踪到底有多少引用指向了这个对象.

1个变量值的引用计数为0时，才会被当做垃圾回收。

x = 1   # 1的引用计数为1
y = 1   # 1的引用计数为2
z = 2   # 1的引用计数为3
z = y   # 1的引用计数为2

print(hex(id(x)))   # 0x7ffb24b016a0
print(hex(id(y)))   # 0x7ffb24b016a0
print(hex(id(z)))   # 0x7ffb24b016a0

引用计数增加的情况

1.对象被创建  a = 1
2.对象被引用  b = a
3.对象被作为参数,传到函数中   func(a)
4.对象作为一个元素，存储在容器中   l1 =

引用计数减少的情况

1.当该对象的别名被显式销毁时  del a
2.当该对象的引别名被赋予新的对象，   a = 30
3.一个对象离开它的作用域，例如 func函数执行完毕时，函数里面的局部变量的引用计数器就会减一（但是全局变量不会）
4.将该元素从容器中删除时，或者容器被销毁时。

2.直接引用 与 间接引用

直接引用：

直接引用指的是从栈区出发直接引用到的内存地址。

x = 10
y = 20
z = 30

print(hex(id(x)))       # 0x7ffb32cd17c0
print(hex(id(y)))       # 0x7ffb32cd1900
print(hex(id(z)))       # 0x7ffb2bec1a40

间接引用：

间接引用指的是从栈区出发引用到堆区后，再通过进一步引用才能到达的内存地址。

x = 10
y = x
l1 = [20, 30]
l2 = [x, l1]

print(hex(id(x)))       # 0x7ffb32cd17c0
print(hex(id(y)))       # 0x7ffb32cd17c0
print(hex(id(l1)))      # 0x293b663fb80
print(hex(id(l2)))      # 0x293b67868c0

循环引用 问题：

l1和l2互相引用

l1 = [1]                    # 此时l1被引用一次，引用计数为1
l2 = [2]                    # 此时l2被引用一次，引用计数为1

l1.append(l2)               # l1=[值1的内存地址，l2列表的内存地址]    #此时l2又被引用一次，引用计数为2
l2.append(l1)               # l2=[值222的内存地址，l1列表的内存地址]  #此时l1又被引用一次，引用计数为2

print(hex(id(l1[0])))       # 0x7ffb231416a0    # 1的内存地址
print(hex(id(l1[1])))       # 0x2be2d426900     # l2的内存地址   # l1引用l2
print(hex(id(l2)))          # 0x2be2d426900

print(hex(id(l2[0])))       # 0x7ffb231416c0    # 2的内存地址
print(hex(id(l2[1])))       # 0x2be2d2dfb80     # l1的内存地址   # l2引用l1
print(hex(id(l1)))          # 0x2be2d2dfb80

print(l2)                   # [2, [1, [...]]]
print(l1[1])                # [2, [1, [...]]]

# 此时，l1和l2互相引用

删除l1和l2后，在堆区的l1和l2的内存地址中还存在着相互引用，使得它们的引用计数始终不为0。

这时候它们就无法被回收，所以循环引用是致命的，这与手动进行内存管理所产生的内存泄露毫无区别。

所以Python引入了“标记-清除” 与“分代回收”来分别解决引用计数的循环引用与效率低的问题

l1 = [1]                    # 此时l1被引用一次，引用计数为1
l2 = [2]                    # 此时l2被引用一次，引用计数为1

l1.append(l2)               # l1=[值1的内存地址，l2列表的内存地址]    #此时l2又被引用一次，引用计数为2
l2.append(l1)               # l2=[值222的内存地址，l1列表的内存地址]  #此时l1又被引用一次，引用计数为2

print(hex(id(l1[0])))       # 0x7ffb231416a0    # 1的内存地址
print(hex(id(l1[1])))       # 0x2be2d426900     # l2的内存地址   # l1引用l2
print(hex(id(l2)))          # 0x2be2d426900

print(hex(id(l2[0])))       # 0x7ffb231416c0    # 2的内存地址
print(hex(id(l2[1])))       # 0x2be2d2dfb80     # l1的内存地址   # l2引用l1
print(hex(id(l1)))          # 0x2be2d2dfb80

print(l2)                   # [2, [1, [...]]]
print(l1[1])                # [2, [1, [...]]]

# 此时，l1和l2互相引用

del l1                      #l1引用次数-1
del l2                      #l2引用次数-1

# 但是此时我们却无法访问l1/l2列表内的内容，本该被当做垃圾删除.
# 但是它的引用计数为1，被l2/l1列表间接引用。
# 这个时候引用计数在这种垃圾身上就失效了。

三：标记 - 清除

容器对象（比如：list，set，dict，class，instance）都可以包含对其他对象的引用，所以都可能产生循环引用。

而“标记-清除”计数就是为了解决循环引用的问题。

标记/清除算法的做法是当应用程序可用的内存空间被耗尽的时，就会停止整个程序，然后进行两项工作，第一项则是标记，第二项则是清除

1.标记

通俗地讲：

栈区相当于“根”，凡是从根出发可以访达（直接或间接引用）的，都称之为“有根之人”，有根之人当活，无根之人当死。

具体地：

标记的过程其实就是，遍历所有的GC Roots对象(栈区中的所有内容或者线程都可以作为GC Roots对象），然后将所有GC Roots的对象可以直接或间接访问到的对象标记为存活的对象，其余的均为非存活对象，应该被清除。

2.清除

清除的过程将遍历堆中所有的对象，将没有标记的对象全部清除掉。

当有了标记 - 清除机制之后，当同时删除l1与l2时，会清理到栈区中l1与l2的内容以及直接引用关系

启用标记清除算法时，从栈区出发，没有任何一条直接或间接引用可以访达l1与l2，即l1与l2成了“无根之人”，于是l1与l2都没有被标记为存活，二者会被清理掉，这样就解决了循环引用带来的内存泄漏问题。

四：分代回收

1.效率问题

基于引用计数的回收机制，每次回收内存，都需要把所有对象的引用计数都遍历一遍，这是非常消耗时间的，于是引入了分代回收来提高回收效率，分代回收采用的是用“空间换时间”的策略。

2.分代

分代回收的核心思想是：

在历经多次扫描的情况下，都没有被回收的变量，gc机制就会认为，该变量是常用变量，gc对其扫描的频率会降低，具体实现原理如下：

分代指的是根据存活时间来为变量划分不同等级（也就是不同的代）

新定义的变量，放到新生代这个等级中，假设每隔1分钟扫描新生代一次，如果发现变量依然被引用，那么该对象的权重（权重本质就是个整数）加一。

当变量的权重大于某个设定得值（假设为3），会将它移动到更高一级的青春代，青春代的gc扫描的频率低于新生代（扫描时间间隔更长），假设5分钟扫描青春代一次。

这样每次gc需要扫描的变量的总个数就变少了，节省了扫描的总时间，接下来，青春代中的对象，也会以同样的方式被移动到老年代中。

也就是等级（代）越高，被垃圾回收机制扫描的频率越低

3.回收

回收依然是使用引用计数作为回收的依据

以班级为例，可以把学生分为三类：学霸、普通学生、学渣

​ 学霸：过于优秀，一周查一次作业

​ 普通学生：一般般，三天查一次

​ 学渣：不用多说，每天都查

虽然分级检查了，检查的时间效率变高了，但是存在着缺陷，如果学霸不交作业，要下一周才能 查出来，那他的学霸地位就不保了，存在漏洞。

没有十全十美的方案：

毫无疑问，如果没有分代回收，即引用计数机制一直不停地对所有变量进行全体扫描，可以更及时地清理掉垃圾占用的内存，但这种一直不停地对所有变量进行全体扫描的方式效率极低，所以我们只能将二者中和。

综上

垃圾回收机制是在清理垃圾&释放内存的大背景下，允许分代回收以极小部分垃圾不会被及时释放为代价，以此换取引用计数整体扫描频率的降低，从而提升其性能，这是一种以空间换时间的解决方案目录。