102 python進階 - GC子產品

一.垃圾回收機制

Python中的垃圾回收是以引用計數為主，分代收集為輔。

1、導緻引用計數+1的情況

• 對象被建立，例如a=23
• 對象被引用，例如b=a
• 對象被作為參數，傳入到一個函數中，例如func(a)
• 對象作為一個元素，存儲在容器中，例如list1=[a,a]

2、導緻引用計數-1的情況

• 對象的别名被顯式銷毀，例如del a
• 對象的别名被賦予新的對象，例如a=24
• 一個對象離開它的作用域，例如f函數執行完畢時，func函數中的局部變量（全局變量不會）
• 對象所在的容器被銷毀，或從容器中删除對象

3、檢視一個對象的引用計數

import sys
a = "hello world"
sys.getrefcount(a)      

可以檢視a對象的引用計數，但是比正常計數大1，因為調用函數的時候傳入a，這會讓a的引用計數+1

二.循環引用導緻記憶體洩露

引用計數的缺陷是循環引用的問題

import gc

class ClassA():
    def __init__(self):
        print('object born,id:%s'%str(hex(id(self))))

def f2():
    while True:
        c1 = ClassA()
        c2 = ClassA()
        c1.t = c2
        c2.t = c1
        del c1
        del c2

#把python的gc關閉
gc.disable()

f2()      

執行f2()，程序占用的記憶體會不斷增大。

• 建立了c1，c2後這兩塊記憶體的引用計數都是1，執行c1.t=c2和c2.t=c1後，這兩塊記憶體的引用計數變成2.
• 在del c1後，記憶體1的對象的引用計數變為1，由于不是為0，是以記憶體1的對象不會被銷毀，是以記憶體2的對象的引用數依然是2，在del c2後，同理，記憶體1的對象，記憶體2的對象的引用數都是1。
• 雖然它們兩個的對象都是可以被銷毀的，但是由于循環引用，導緻垃圾回收器都不會回收它們，是以就會導緻記憶體洩露。

三.垃圾回收

#coding=utf-8
import gc

class ClassA():
    def __init__(self):
        print('object born,id:%s'%str(hex(id(self))))
    # def __del__(self):
    #     print('object del,id:%s'%str(hex(id(self))))

def f3():
    print("-----0------")
    # print(gc.collect())
    c1 = ClassA()
    c2 = ClassA()
    c1.t = c2
    c2.t = c1
    print("-----1------")
    del c1
    del c2
    print("-----2------")
    print(gc.garbage)
    print("-----3------")
    print(gc.collect()) #顯式執行垃圾回收
    print("-----4------")
    print(gc.garbage)
    print("-----5------")

if __name__ == '__main__':
    gc.set_debug(gc.DEBUG_LEAK) #設定gc子產品的日志
    f3()      

python2運作結果:

-----0------
object born,id:0x724b20
object born,id:0x724b48
-----1------
-----2------
[]
-----3------
gc: collectable <ClassA instance at 0x724b20>
gc: collectable <ClassA instance at 0x724b48>
gc: collectable <dict 0x723300>
gc: collectable <dict 0x71bf60>
4
-----4------
[<__main__.ClassA instance at 0x724b20>, <__main__.ClassA instance at 0x724b48>, {'t': <__main__.ClassA instance at 0x724b48>}, {'t': <__main__.ClassA instance at 0x724b20>}]
-----5------      

說明:

• 垃圾回收後的對象會放在gc.garbage清單裡面
• gc.collect()會傳回不可達的對象數目，4等于兩個對象以及它們對應的dict

有三種情況會觸發垃圾回收：

1. 調用gc.collect(),
2. 當gc子產品的計數器達到閥值的時候。
3. 程式退出的時候

四.gc子產品常用功能解析

​

​gc子產品提供一個接口給開發者設定垃圾回收的選項​

​。上面說到，采用引用計數的方法管理記憶體的一個缺陷是循環引用，而gc子產品的一個主要功能就是解決循環引用的問題。

​常用函數：​

1、gc.set_debug(flags) 設定gc的debug日志，一般設定為gc.DEBUG_LEAK

2、gc.collect([generation]) 顯式進行垃圾回收，可以輸入參數，0代表隻檢查第一代的對象，1代表檢查一，二代的對象，2代表檢查一，二，三代的對象，如果不傳參數，執行一個full collection，也就是等于傳2。 傳回不可達（unreachable objects）對象的數目。

3、gc.get_threshold() 擷取的gc子產品中自動執行垃圾回收的頻率。

4、gc.set_threshold(threshold0[, threshold1[, threshold2]) 設定自動執行垃圾回收的頻率。

5、gc.get_count() 擷取目前自動執行垃圾回收的計數器，傳回一個長度為3的清單。

gc子產品的自動垃圾回收機制

必須要import gc子產品，并且is_enable()=True才會啟動自動垃圾回收。

這個機制的主要作用就是發現并處理不可達的垃圾對象。

垃圾回收=垃圾檢查+垃圾回收

在Python中，采用分代收集的方法。把對象分為三代，一開始，對象在建立的時候，放在一代中，如果在一次一代的垃圾檢查中，改對象存活下來，就會被放到二代中，同理在一次二代的垃圾檢查中，該對象存活下來，就會被放到三代中。

gc子產品裡面會有一個長度為3的清單的計數器，可以通過gc.get_count()擷取。

例如(488,3,0)，其中488是指距離上一次一代垃圾檢查，Python配置設定記憶體的數目減去釋放記憶體的數目，注意是記憶體配置設定，而不是引用計數的增加。例如：

print gc.get_count() # (590, 8, 0)
a = ClassA()
print gc.get_count() # (591, 8, 0)
del a
print gc.get_count() # (590, 8, 0)      

3是指距離上一次二代垃圾檢查，一代垃圾檢查的次數，同理，0是指距離上一次三代垃圾檢查，二代垃圾檢查的次數。

gc模快有一個自動垃圾回收的閥值，即通過gc.get_threshold函數擷取到的長度為3的元組，例如(700,10,10) 每一次計數器的增加，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子產品唯一處理不了的是循環引用的類都有__del__方法，是以項目中要避免定義__del__方法

import gc

class ClassA():
    pass
    # def __del__(self):
    #     print('object born,id:%s'%str(hex(id(self))))

gc.set_debug(gc.DEBUG_LEAK)
a = ClassA()
b = ClassA()

a.next = b
b.prev = a

print "--1--"
print gc.collect()
print "--2--"
del a
print "--3--"
del b
print "--3-1--"
print gc.collect()
print "--4--"      

運作結果：

--1--
0
--2--
--3--
--3-1--
gc: collectable <ClassA instance at 0x21248c8>
gc: collectable <ClassA instance at 0x21248f0>
gc: collectable <dict 0x2123030>
gc: collectable <dict 0x2123150>
4
--4--      

--1--
0
--2--
--3--
--3-1--
gc: uncollectable <ClassA instance at 0x6269b8>
gc: uncollectable <ClassA instance at 0x6269e0>
gc: uncollectable <dict 0x61bed0>
gc: uncollectable <dict 0x6230c0>
4
--4--