标记清理是用来解决循环引用的。分代回收针对所有的新创建即进入0代的对象和进入1、2代的对象。。这样就解释了python“引用计数为主。标记清理+分代回收为辅”的垃圾回收原理，因为循环引用毕竟是少数情况。
# 没有循环引用的情况，随着del、函数退出等触发条件，立即删除所占用内存 import gc import sys gc.set_debug(gc.DEBUG_STATS|gc.DEBUG_COLLECTABLE|gc.DEBUG_UNCOLLECTABLE|gc.DEBUG_SAVEALL|gc.DEBUG_LEAK) a=[] b=[] print(hex(id(a))) print(hex(id(b))) a.append(b) print('a refcount:',sys.getrefcount(a)) # 2 print('b refcount:',sys.getrefcount(b)) # 3 del a # 这里已经删除了，内存也被回收了，所以在gc进行垃圾回收的时候，不需要处理，毕竟gc是根据阈值设置触发执行的，没有立即删除那么快 del b # 这里已经删除了，内存也被回收了，所以在gc进行垃圾回收的时候，不需要处理 print(gc.collect()) # 0
#放在解释器里执行：
>>> a=[] >>> b=[] >>> print(hex(id(a))) 0x102918788 >>> print(hex(id(b))) 0x1029187c8 >>> a.append(b) >>> print('a refcount:',sys.getrefcount(a)) # 2 a refcount: 2 >>> print('b refcount:',sys.getrefcount(b)) # 3 b refcount: 3 >>> ... del a # 这里已经删除了，内存也被回收了，所以在gc进行垃圾回收的时候，不需要处理 >>> del b # 这里已经删除了，内存也被回收了，所以在gc进行垃圾回收的时候，不需要处理 >>> print(gc.collect()) # 0 gc: collecting generation 2... gc: objects in each generation: 4 0 4338 gc: objects in permanent generation: 0 gc: done, 0.0009s elapsed 0 -----没有任何对象被回收 >>>
# 下面的示例是存在循环引用的情况，所以del删除的时候，只是删除了对象的引用，对象没有被删除，所以在gc进行垃圾回收的时候，所用内存经过标记清理和分代回收动作被回收掉 a=[] b=[] print(hex(id(a))) print(hex(id(b))) a.append(b) b.append(a) del a del b print(gc.collect())
# 放到python3.7解释器里执行 >>> a=[] >>> b=[] >>> print(hex(id(a))) 0x102828888 >>> print(hex(id(b))) 0x102828848 >>> a.append(b) >>> b.append(a) >>> del a >>> del b >>> print(gc.collect()) gc: collecting generation 2... gc: objects in each generation: 6 0 4336 gc: objects in permanent generation: 0 gc: collectable <list 0x102828888> gc: collectable <list 0x102828848> gc: done, 2 unreachable, 0 uncollectable, 0.0010s elapsed 2 0---表示存在2个不可达对象，0个不可以回收的对象 2 --- 表示被回收了2个不可达对象 >>>
# 下面这段代码在python3.7中执行不存在内存泄露；但是在python2.7环境中存在内存泄露 class A: def __del__(self): pass class B: def __del__(self): pass a=A() b=B() print(hex(id(a))) print(hex(id(a.__dict__))) a.b=b b.a=a del a del b print(gc.collect()) print(gc.garbage)
# pyhton3.7环境下执行 >>> class A: ... def __del__(self): ... pass ... >>> ... class B: ... def __del__(self): ... pass ... >>> >>> a=A() >>> b=B() >>> print(hex(id(a))) 0x10cfbfba8 >>> print(hex(id(a.__dict__))) 0x10ce64f78 >>> a.b=b >>> b.a=a >>> del a >>> del b >>> ... print(gc.collect()) gc: collecting generation 2... gc: objects in each generation: 683 3813 0 gc: objects in permanent generation: 0 gc: collectable <A 0x10cfbfba8> gc: collectable <B 0x10cfbfd68> gc: collectable <dict 0x10ce64f78> gc: collectable <dict 0x10cf083f0> gc: done, 4 unreachable, 0 uncollectable, 0.0008s elapsed 4 0 --- 存在4个不可达但是不存在不可以回收的对象，即4个不可达对象都可以回收 4 ---回收了4个不可达的对象 >>> print(gc.garbage) [<__main__.A object at 0x10cfbfba8>, <__main__.B object at 0x10cfbfd68>, {'b': <__main__.B object at 0x10cfbfd68>}, {'a': <__main__.A object at 0x10cfbfba8>}] >>>
# python2.7环境下执行 >>> class A: ... def __del__(self): ... pass ... gc: collecting generation 0... gc: objects in each generation: 658 3204 0 gc: done, 0.0002s elapsed. >>> >>> class B: ... def __del__(self): ... pass ... >>> a=A() >>> b=B() >>> print(hex(id(a))) 0x10239a2d8 >>> print(hex(id(a.__dict__))) 0x10239b050 >>> a.b=b >>> b.a=a >>> del a >>> del b >>> ... print(gc.collect()) gc: collecting generation 2... gc: objects in each generation: 16 3552 0 gc: uncollectable <A instance at 0x10239a2d8> gc: uncollectable <B instance at 0x10239a320> gc: uncollectable <dict 0x10239b050> gc: uncollectable <dict 0x102398c58> gc: done, 4 unreachable, 4 uncollectable, 0.0008s elapsed. 4 4--- 存在4个不可达又不可以回收的对象 4 --- 回收了4个不可达对象 >>> print(gc.garbage) [<__main__.A instance at 0x10239a2d8>, <__main__.B instance at 0x10239a320>, {'b': <__main__.B instance at 0x10239a320>}, {'a': <__main__.A instance at 0x10239a2d8>}] >>> >>>
这篇文章：https://python3-cookbook.readthedocs.io/zh_CN/latest/c08/p23_managing_memory_in_cyclic_data_structures.html举例的内存泄露的情况，也只有在python2.x中存在，python3.x貌似做了优化，并没有内存泄露：
如果循环引用的对象自己还定义了自己的 __del__() 方法，那么会让情况变得更糟糕。 假设你像下面这样给Node定义自己的 __del__() 方法：
# Class just to illustrate when deletion occurs class Data: def __del__(self): print('Data.__del__') # Node class involving a cycle class Node: def __init__(self): self.data = Data() self.parent = None self.children = [] def add_child(self, child): self.children.append(child) child.parent = self # NEVER DEFINE LIKE THIS. # Only here to illustrate pathological behavior def __del__(self): del self.data In [3]: a=Node() In [4]: a.add_child(Node()) In [5]: del a In [6]: import gc In [7]: gc.collect() Out[7]: 56 In [8]: gc.garbage Out[8]: [<__main__.Node instance at 0x107a6b200>, <__main__.Data instance at 0x107d21638>, <__main__.Node instance at 0x107a565f0>, <__main__.Data instance at 0x107dd3518>]
参考：
https://blog.csdn.net/yueguanghaidao/article/details/11274737