GC模块一些方法介绍

gc.disable()
```
禁用垃圾收回
```
gc.enable()
```
启用垃圾收回
```

gc.isenabled()

查看是否启用了垃圾收回。
print(gc.isenabled()) # True
print(gc.disable())   # Node
print(gc.isenabled()) #False
print(gc.get_count()) # (669, 11, 0)

gc.get_objects()

返回由收集器跟踪的所有对象的列表，不包括返回的列表。

gc.collect()

gc.collect()命令可以回收没有被使用的空间，但是这个命令还会返回一个数值，是清除掉的垃圾变量的个数【不可达的对象数目】。
> 补充说明：
显式进行垃圾回收，可以输入参数，
0代表只检查第一代的对象，
1代表检查一，二代的对象，
2代表检查一，二，三代的对象，
如果不传参数，执行一个full collection，也就是等于传2。 
最终返回不可达（unreachable objects）对象的数目

PS：
reachable objects 可达对象（可回收对象）
unreachable objects  不可达（unreachable objects）对象（不可回收对象）

一个见证手动回收和不手动回收示例：

不进行手动回收的：

  import gc
  import sys
  import ctypes


  class PyObject(ctypes.Structure):
      _fields_ = [("refcnt", ctypes.c_long)]


  obj1 = dict()
  obj2 = dict()
  obj1["obj2"] = obj2
  obj2["obj1"] = obj1
  obj1_addr, obj2_addr = id(obj1), id(obj2)
  del obj1
  del obj2
  # gc.collect()
  print(PyObject.from_address(obj1_addr).refcnt)
  print(PyObject.from_address(obj2_addr).refcnt)

输出：
1
1

进行手动回收的：

  import gc
  import sys
  import ctypes


  class PyObject(ctypes.Structure):
      _fields_ = [("refcnt", ctypes.c_long)]


  obj1 = dict()
  obj2 = dict()
  obj1["obj2"] = obj2
  obj2["obj1"] = obj1
  obj1_addr, obj2_addr = id(obj1), id(obj2)
  del obj1
  del obj2
  gc.collect()
  print(PyObject.from_address(obj1_addr).refcnt)
  print(PyObject.from_address(obj2_addr).refcnt)

输出：
0
0

gc.set_debug(flags)

- 1、设置当前收集器的调试状态，可通过该函数打印经过收集器的所有对象信息，不可访问的对象信息等等，
- 2、还可以将不可访问的对象保存至gc.garbage列表中(即不释放该对象)，以便开发人员定位。
- 3、默认一般设置为gc.DEBUG_LEAK
PS：
如果设置了gc.DEBUG_SAVEALL，那么所有的unreachable对象都将加入gc.garbage返回的列表，而不止不能被回收的对象。

gc.get_debug()
```
返回当前设置的调试标志。
```

gc.get_threshold()

获取分代机制机制回收垃圾各代的回收频率的阀值。

资料来自：http://www.manongjc.com/article/59800.html
分代收集的思想是活的越久的对象，就越不是垃圾，回收的频率就应该越低。
它分代回收的阀值递增机制:
- 每一次计数器的增加，gc模块就会检查增加后的计数是否达到阀值的数目，
- 如果是，就会执行对应的代数的垃圾检查，然后重置计数器.

例如，假设阀值是(700,10,10)：
当计数器从(699,3,0)增加到(700,3,0)，gc模块会执行gc.collect(0),检查一代对象的垃圾，并重置计数器为(0,4,0)
当计数器从(699,9,0)增加到(700,9,0)，gc模块会执行gc.collect(1),检查一、二代对象的垃圾，并重置计数器为(0,0,1)
当计数器从(699,9,9)增加到(700,9,9)，gc模块会执行gc.collect(2),检查一、二、三代对象的垃圾，并重置计数器为(0,0,0)

gc.set_threshold(threshold0[, threshold1[, threshold2])

手动设置分代机制机制回收垃圾各代的回收频率的阀值

gc.get_count()
```
获取当前自动执行垃圾回收的计数器，返回一个长度为3的列表
如：
```
```
import gc


class Ceshi:
    pass

    def aaaa(self):
        print("我是测试")


print(gc.get_count())  # (689, 11, 0)
a = Ceshi()
print(gc.get_count())  # (692, 11, 0)
del a
print(gc.get_count())  # (691, 11, 0)
```
- 689：表示的是距离上一次一代垃圾检查，Python分配内存的数目减去释放内存的数目，注意是内存分配数，而不是引用计数的增加
- 11: 指距离上一次二代垃圾检查，一代垃圾检查的次数
- 0: 指距离上一次三代垃圾检查，二代垃圾检查的次数。

gc.garbage

返回是unreachable对象，不可回收的对象。
意思是这存放无法释放的对象（引发内存泄漏对象）详细信息，是一个列表，可通过len(gc.garbage)查看造成内存泄漏的对象个数。

可能存在应用泄漏的示例（3.4之前应该是，不过3.5后没看到了）

import time
import gc


class A():

    def __init__(self):
        pass

    def __del__(self):
        pass


def test_leak():
    c1 = A()
    c2 = A()

    c1.t = c2
    c2.t = c1

    c1.t2 = c2
    c2.t3 = c1

    del c1
    del c2


if __name__ == '__main__':
    pass
    test_leak()
    print(gc.collect())  # 输出4
    print(len(gc.garbage))  # 如果这了输出2，有两个垃圾变量未被回收，说明发生内存泄漏
    print(gc.garbage)