【一】引入

• 解释器在执行到定义变量的语法时，会申请内存空间来存放变量的值，而内存的容量是有限的，这就涉及到变量值所占用内存空间的回收问题

• 当一个变量值没有用了（简称垃圾）就应该将其占用的内存给回收掉，那什么样的变量值是没有用的呢？

• 单从逻辑层面分析，我们定义变量将变量值存起来的目的是为了以后取出来使用，而取得变量值需要通过其绑定的直接引用（如x=10，10被x直接引用）或间接引用（如l=[x,]，x=10，10被x直接引用，而被容器类型l间接引用）

• 所以当一个变量值不再绑定任何引用时，我们就无法再访问到该变量值了，该变量值自然就是没有用的，就应该被当成一个垃圾回收。

• 毫无疑问，内存空间的申请与回收都是非常耗费精力的事情，而且存在很大的危险性，稍有不慎就有可能引发内存溢出问题

• 好在Cpython解释器提供了自动的垃圾回收机制来帮我们解决了这件事。

【二】什么是垃圾回收机制

• 垃圾回收机制（简称GC）是Python解释器自带的一种机制
• 专门用来回收不可用的变量值所占用的内存空间（在内存中，没有变量名指向的数据都是垃圾数据）

【三】为什么要有垃圾回收机制

• 程序运行过程中会申请大量的内存空间，而对于一些无用的内存空间如果不及时清理的话会导致内存使用殆尽（内存溢出），导致程序崩溃
• 因此管理内存是一件重要且繁杂的事情，而python解释器自带的垃圾回收机制把程序员从繁杂的内存管理中解放出来。

【四】GC原理

【1】堆区和栈区

• 在定义变量时，变量名与变量值都是需要存储的
• 分别对应内存中的两块区域：
  • 堆区
    • 变量名与值内存地址的关联关系存放于栈区
  • 栈区
    • 变量值存放于堆区，内存管理回收的则是堆区的内容，
• 示例
  • 定义了两个变量x = 10、y = 20，详解如下图

• 当我们执行x=y时，内存中的栈区与堆区变化如下

【2】直接引用与间接引用

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

l2 = [20, 30] # 列表本身被变量名l2直接引用，包含的元素被列表间接引用 
x = 10  	  # 值10被变量名x直接引用
l1 = [x, l2]  # 列表本身被变量名l1直接引用，包含的元素被列表间接引用

• 图解

【五】垃圾回收机制原理

• 引用计数为主，垃圾回收、分代回收为辅。

• Python的GC模块主要运用了“引用计数”（reference counting）来跟踪和回收垃圾。
• 在引用计数的基础上，还可以通过“标记-清除”（mark and sweep）解决容器对象可能产生的循环引用的问题，并且通过“分代回收”（generation collection）以空间换取时间的方式来进一步提高垃圾回收的效率。

【1】引用计数

（1）引用计数

• 引用计数就是：变量值被变量名关联的次数
  • 如：age=18
• 变量值18被关联了一个变量名age，称之为引用计数为1

（2）引用计数增加

• age=18 （此时，变量值18的引用计数为1）

• m=age （把age的内存地址给了m，此时，m,age都关联了18，所以变量值18的引用计数为2）

（3）引用计数减少

• age=10（名字age先与值18解除关联，再与3建立了关联，变量值18的引用计数为1）

• del m（del的意思是解除变量名x与变量值18的关联关系，此时，变量18的引用计数为0）

• 值18的引用计数一旦变为0，其占用的内存地址就应该被解释器的垃圾回收机制回收

（4）小结

• 一个变量值可以有多个变量名指向，有一个变量名指向，引用计数就是1，有两个就是2

• 只要引用计数不为0，这个变量值就不是垃圾数据，当引用计数为0了，说明这个变量值就没用了，就可以清除了

一个变量名只能指向一个内存空间： 意味着一个变量名在某一时刻只能代表一个值。当你给一个变量赋新值时，它将指向新的内存空间，不再指向之前的。

一个内存空间可以被多个变量名指向： 多个变量名可以同时指向相同的内存空间。这意味着如果你改变了这个内存空间的值，所有指向它的变量都会受到影响。

（5）引用计数的问题

• 引用计数机制存在着一个致命的弱点，即循环引用（也称交叉引用）

# 如下我们定义了两个列表，简称列表1与列表2，变量名l1指向列表1，变量名l2指向列表2
l1 = ['xxx']  # 列表1被引用一次，列表1的引用计数变为1
l2 = ['yyy']  # 列表2被引用一次，列表2的引用计数变为1
l1.append(l2)  # 把列表2追加到l1中作为第二个元素，列表2的引用计数变为2
l2.append(l1)  # 把列表1追加到l2中作为第二个元素，列表1的引用计数变为2

# 1. l1与l2之间有相互引用
# 2. l1 = ['xxx'的内存地址,列表2的内存地址]
# 3. l2 = ['yyy'的内存地址,列表1的内存地址]

print(l1)  # ['xxx', ['yyy', [...]]]

print(l2)  # ['yyy', ['xxx', [...]]]

• 循环引用会导致：
  • 值不再被任何名字关联，但是值的引用计数并不会为0，应该被回收但不能被回收
• 什么意思呢？试想一下，请看如下操作

# 如下我们定义了两个列表，简称列表1与列表2，变量名l1指向列表1，变量名l2指向列表2
l1 = ['xxx']  # 列表1被引用一次，列表1的引用计数变为1
l2 = ['yyy']  # 列表2被引用一次，列表2的引用计数变为1
l1.append(l2)  # 把列表2追加到l1中作为第二个元素，列表2的引用计数变为2
l2.append(l1)  # 把列表1追加到l2中作为第二个元素，列表1的引用计数变为2

# 1. l1与l2之间有相互引用
# 2. l1 = ['xxx'的内存地址,列表2的内存地址]
# 3. l2 = ['yyy'的内存地址,列表1的内存地址]

print(l1)  # ['xxx', ['yyy', [...]]]

print(l2)  # ['yyy', ['xxx', [...]]]

del l1  # 列表1的引用计数减1，列表1的引用计数变为1
del l2  # 列表2的引用计数减1，列表2的引用计数变为1

print(l1)  # name 'l1' is not defined

print(l2)  # name 'l2' is not defined

• 此时，只剩下列表1与列表2之间的相互引用

• 但此时两个列表的引用计数均不为0，但两个列表不再被任何其他对象关联，没有任何人可以再引用到它们
  • 所以它俩占用内存空间应该被回收，但由于相互引用的存在，每一个对象的引用计数都不为0
  • 因此这些对象所占用的内存永远不会被释放，所以循环引用是致命的，这与手动进行内存管理所产生的内存泄露毫无区别。
• 所以Python引入了“标记-清除” 与“分代回收”来分别解决引用计数的循环引用与效率低的问题

【2】标记-清除

（1）标记-清除算法

• 在Python的内存管理中，标记-清除算法是一种常用的垃圾回收（Garbage Collection）方法之一。它的主要目标是解决循环引用导致的内存泄漏问题。

• 通俗理解为当内存空间即将沾满的时候，python会暂停程序的运行，从头到位扫描一遍，并且把扫描出来的垃圾数据做标记，然后，一次性做清除处理

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

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

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

（2）标记阶段

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

• 标记GC Roots： 栈区中的所有内容或者线程都可以作为GC Roots对象。这些对象被认为是根源，是可达的。在标记阶段，遍历GC Roots对象，将可以直接或间接访问到的对象标记为存活对象。

• 标记存活对象： 遍历所有GC Roots的对象引用链，将可达的对象进行标记。这些对象将被保留，认为是存活的。

（3）清除阶段

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

• 清除非存活对象： 遍历整个堆内存，将没有被标记的对象认定为非存活对象，进行清除操作。这些对象所占用的内存空间将被释放。

（4）循环引用的处理

• 标记-清除算法解决了循环引用的问题。当两个对象互相引用，但与GC Roots没有直接引用关系时，它们在标记阶段将被标记为非存活对象，然后在清除阶段被释放。

• 基于上例的循环引用，当我们同时删除l1与l2时，会清理到栈区中l1与l2的内容以及直接引用关系

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

（5）标记-清除的问题

• 效率： 标记-清除算法可能导致程序在执行过程中停顿，因为在标记和清除阶段，程序的执行会被暂停一段时间。这可能会影响对实时性要求较高的应用程序。
• 空间碎片： 清除阶段释放的内存可能导致堆内存出现空间碎片。在长时间运行的程序中，这可能会导致内存的浪费。

【3】分代回收

（1）分代回收的核心思想

• 分代回收是一种垃圾回收的策略，其核心思想是根据对象的存活时间将其划分为不同的代（generation）。

• 在Python中，通常将内存分为三代：

  • 新生代（young generation）： 包含了大部分新创建的对象，其存活时间较短。

  • 青春代（youth generation）： 包含了已经经历过垃圾回收一次的新生代对象，存活时间较长。

  • 老年代（old generation）： 包含了已经经历过多次垃圾回收的对象，存活时间较长。

（2）具体实现原理

• 大部分对象在其刚被创建的时候往往很快变得不可达，即它们的生命周期较短。

• 部分对象在经历了一次垃圾回收后，仍然存活的概率较高，即它们的生命周期较长。

• 因此，分代回收将内存划分为不同的代，并根据代的特点采用不同的垃圾回收策略。

  • 新生代中的对象：采用较为频繁的垃圾回收，通常使用标记-复制算法，即标记存活对象，然后将存活对象复制到另一块内存中，最后清理掉原有的内存。这能有效处理新生代中大部分对象的垃圾回收。

  • 青春代中的对象：采用标记-清除算法，其目标是处理在新生代中经历了一次回收的对象。由于这些对象的生命周期较长，不需要频繁地进行回收。

  • 老年代中的对象：采用标记-清除算法或标记-整理算法。老年代的对象生命周期更长，采用相对稳定的垃圾回收策略。

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

新定义的变量，放到新生代这个等级中，假设每隔1分钟扫描新生代一次，如果发现变量依然被引用，那么该对象的权重（权重本质就是个整数）加一，当变量的权重大于某个设定得值（假设为3），会将它移动到更高一级的青春代，

青春代的gc扫描的频率低于新生代（扫描时间间隔更长），假设5分钟扫描青春代一次，这样每次gc需要扫描的变量的总个数就变少了，节省了扫描的总时间，

接下来，青春代中的对象，也会以同样的方式被移动到老年代中。

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

（3）回收

• 分代回收机制对不同代的垃圾回收频率进行了调整：
  • 新生代的垃圾回收比较频繁，因为大部分对象在新生代中被创建后很快就变得不可达。
  • 青春代的垃圾回收频率较低，因为这些对象已经经历了一次回收，存活概率相对较高。
  • 老年代的垃圾回收频率较低，因为老年代的对象生命周期较长。

（4）分代回收的问题

• 新生代到青春代的延迟问题： 当一个变量从新生代移入青春代时，其绑定关系解除，应该被回收。然而，由于青春代的扫描频率低于新生代，可能导致这些变量的垃圾没有得到及时的清理。

• 权重提升的不精确性： 分代回收中通过给对象的权重进行提升来判断其生命周期。然而，这种机制并不完美，可能存在一些不够准确的情况，导致有些垃圾对象没有被及时清理。

• 无法解决循环引用的所有问题： 尽管分代回收可以处理一些循环引用的情况，但并不能解决所有可能的循环引用问题。在某些情况下，仍然需要手动处理循环引用，例如通过显式地断开引用或使用弱引用。

• 全局解释器锁（GIL）： 在多线程的情况下，全局解释器锁可能会影响垃圾回收的效率，尤其是对于CPU密集型的任务。在处理大规模数据或高并发情况下，需要考虑GIL的影响。

• 没有十全十美的方案：

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

【4】小结

• 垃圾回收机制在清理垃圾和释放内存的背景下发挥着重要的作用。
• 通过引入分代回收，系统在极小部分垃圾不会被及时释放的代价下，降低了引用计数整体扫描的频率，从而提升了性能。
• 这是一种以空间换时间的解决方案，通过划分不同代别的对象，根据它们的存活时间采取不同的垃圾回收策略。
• 在实际应用中，垃圾回收机制的设计需要综合考虑性能、精确度和实现的复杂性等因素。
• 尽管存在一些问题，如新生代到青春代的延迟、权重提升的不精确性等，但分代回收仍然是一种有效的策略，通过权衡各种因素，系统可以更好地管理内存，提高程序的运行效率。