Python 記憶體回收機制

標籤：釋放記憶體   記憶體泄露   自動   cti   ble   項目   元組   集中   一個   

一、Python記憶體回收機制

Python中的記憶體回收是以引用計數為主，分代收集為輔。

在Python中，如果一個對象的引用數為0，Python虛擬機器就會回收這個對象的記憶體。

class A:    def __init__(self):        self.t = None        print ‘new obj, id is %s‘ %str(hex(id(self)))        def __del__(self):        print ‘del obj, id id %s‘ %str(hex(id(self)))if __name__ == ‘__main__‘:    while True:        a1 = A()        del a1

 

運行如上代碼，進程佔用的記憶體基本不會變動

new obj, id is 0x2a79d48Ldel obj, id id 0x2a79d48L

 

a = A() 會建立一個對象，在0x2a79d48L記憶體中，a變數指向這個記憶體，這時候這個記憶體的引用計數是1

del a後，a變數不再指向0x2a79d48L記憶體，所以這塊記憶體的引用計數減一，等於0，所以就銷毀了這個對象，然後釋放記憶體。

導致引用計數+1的情況

　　1) 對象被建立，例如a=23

　　2) 對象被引用，例如b=a

　　3) 對象被作為參數，傳入到一個函數中，例如func(a)

　　4）對象作為一個元素，儲存在容器中，例如list1=[a,a]

導致引用計數-1的情況

　　1) 對象的別名被顯式銷毀，例如del a

　　2) 對象的別名被賦予新的對象，例如a=24

　　3) 一個對象離開它的範圍，例如f函數執行完畢時，func函數中的局部變數（全域變數不會）

　　4) 對象所在的容器被銷毀，或從容器中刪除對象

二、demo查看引用計數

def func(c):    print ‘in func function‘, sys.getrefcount(c) - 1print ‘init‘, sys.getrefcount(11) - 1a = 11print ‘after a=11‘, sys.getrefcount(11) - 1b = aprint ‘after b=a‘, sys.getrefcount(11) - 1func(11)print ‘after func(a)‘, sys.getrefcount(11) - 1list1 = [a, 12, 14]print ‘after list1=[a,12,14]‘, sys.getrefcount(11) - 1a=12print ‘after a=12‘, sys.getrefcount(11) - 1del aprint ‘after del a‘, sys.getrefcount(11) - 1del bprint ‘after del b‘, sys.getrefcount(11) - 1list1.pop(0)print ‘after pop list1‘,sys.getrefcount(11)-1del list1print ‘after del list1‘, sys.getrefcount(11) - 1

 

輸出：

init 67after a=11 68after b=a 69in func function 72after func(a) 69after list1=[a,12,14] 70after a=12 69after del a 69after del b 68after pop list1 67after del list1 67

 

問題：為什麼調用函數會令引用計數+2

sys.getrefcount(a) 可以查看a對象的引用計數，但是比正常計數大1，因為調用函數的時候傳入a，這會讓a的引用計數+1

三、循環參考導致記憶體泄露

class A:    def __init__(self):        self.t = None        print ‘new obj, id is %s‘ %str(hex(id(self)))        def __del__(self):        print ‘del obj, id id %s‘ %str(hex(id(self)))if __name__ == ‘__main__‘:    while True:        a1 = A()        a2 = A()        a1.t = a2        a2.t = a1        del a1        del a2

 

執行如上代碼，進程佔用的記憶體會不斷增大。

new obj, id is 0x3475348Lnew obj, id is 0x3475388L

 

建立了a1，a2後，0x3475348L（a1對應的記憶體，記為記憶體1）,0x3475388L（c2對應的記憶體，記為記憶體2）這兩塊記憶體的引用計數都是1，執行a1.t = a2和a2.t = a1後，這兩塊記憶體的引用計數變成2.

在del a1後，記憶體1的對象的引用計數變為1，由於不是為0，所以記憶體1的對象不會被銷毀，所以記憶體2的對象的引用數依然是2，在del c2後，同理，記憶體1的對象，記憶體2的對象的引用數都是1。

雖然它們兩個的對象都是可以被銷毀的，但是由於循環參考，導致記憶體回收行程都不會回收它們，所以就會導致記憶體泄露。

當然，上面這是一種特殊情況，因為classA定義了__del__(self): 函數，並且存在循環參考，這有這種情況的循環參考，gc不能確定先調用那個del，所以不能進行回收。若果classA沒有定義__del__(self):函數，gc是能夠自動打破循環參考的。

四、Python gc模組

有了循環參考的問題，當然就會有解決辦法，python gc模組提供了一種機制，使我們能夠訪問那些定義了__del__(self): 函數又存在循環參考的對象。

class A:    def __init__(self):        self.t = None        print ‘new obj, id is %s‘ %str(hex(id(self)))        def __del__(self):        print ‘del obj, id id %s‘ %str(hex(id(self)))def f():    c1=A()    c2=A()    c1.t=c2    c2.t=c1    del c1    del c2    print gc.collect() #顯式執行記憶體回收    print gc.garbageif __name__ == ‘__main__‘:    gc.set_debug(gc.DEBUG_UNCOLLECTABLE) #設定gc模組的日誌    f()

 

gc.set_debug(gc.DEBUG_UNCOLLECTABLE)設定gc模組在執行清理後，將uncollectable對象放在gc.garbage裡，上面代碼運行結果：

new obj, id is 0x2b8f148Lnew obj, id is 0x2b8f3c8L4[<__main__.A instance at 0x0000000002B8F148>, <__main__.A instance at 0x0000000002B8F3C8>]

 

我們建立的兩個對象（0x2aff148l, 0x2aff3c8l）循環參考後並del後, 都放在了gc.garbage裡，所以他們都是uncollectable類型的對象，我們解除循環參考，就可以遍曆gc.garbage這個對象，並將garbage對象裡的對象的del掉即可。

五、Python三代回收

在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 aprint 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模組，啟動gc模組的自動清理循環參考的對象機制
• 由於分代收集，所以把需要長期使用的變數集中管理，並儘快移到二代以後，減少GC檢查時的消耗
• gc模組唯一處理不了的是循環參考的類都有__del__方法，所以項目中要避免定義__del__方法，如果一定要使用該方法，同時導致了循環參考，需要代碼顯式調用gc.garbage裡面的對象的__del__來打破僵局

參考文檔：https://docs.python.org/2.7/library/gc.html

 

Python 記憶體回收機制