Python垃圾回收機制詳解

Python中的垃圾回收是以引用計數為主，分代收集為輔。引用計數的缺陷是循環引用的問題。

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

#encoding=utf-8
__author__ = 'kevinlu1010@qq.com'
 
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)))
 
deff1():
    while True:
        c1=ClassA()
        delc1

執行f1()會循環輸出這樣的結果，而且進程占用的內存基本不會變動

object born,id:0x237cf58
object del,id:0x237cf58

c1=ClassA() 會創建一個對象，放在 0x237cf58 內存中，c1變量指向這個內存，這時候這個內存的引用計數是1

del c1 后，c1變量不再指向 0x237cf58 內存，所以這塊內存的引用計數減一，等于0，所以就銷毀了這個對象，然后釋放內存。

1. 導致引用計數+1的情況
   1. 對象被創建，例如 a=23
   2. 對象被引用，例如 b=a
   3. 對象被作為參數，傳入到一個函數中，例如 func(a)
   4. 對象作為一個元素，存儲在容器中，例如 list1=[a,a]

2. 導致引用計數-1的情況

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

   demo

   deffunc(c,d):
       print 'in func function', sys.getrefcount(c) - 1
    
    
   print 'init', sys.getrefcount(11) - 1
   a = 11
   print 'after a=11', sys.getrefcount(11) - 1
   b = a
   print 'after b=1', sys.getrefcount(11) - 1
   func(11)
   print 'after func(a)', sys.getrefcount(11) - 1
   list1 = [a, 12, 14]
   print 'after list1=[a,12,14]', sys.getrefcount(11) - 1
   a=12
   print 'after a=12', sys.getrefcount(11) - 1
   del a
   print 'after del a', sys.getrefcount(11) - 1
   del b
   print 'after del b', sys.getrefcount(11) - 1
   # list1.pop(0)
   # print 'after pop list1',sys.getrefcount(11)-1
   dellist1
   print 'after del list1', sys.getrefcount(11) - 1
   

   輸出：

   init 24
   after a=11 25
   after b=1 26
   in funcfunction 28
   afterfunc(a) 26
   afterlist1=[a,12,14] 27
   after a=12 26
   afterdel a 26
   afterdel b 25
   afterdellist1 24
   

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

3. 查看一個對象的引用計數

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

二.循環引用導致內存泄露

deff2():
    while True:
        c1=ClassA()
        c2=ClassA()
        c1.t=c2
        c2.t=c1
        delc1
        delc2
        

執行f2()，進程占用的內存會不斷增大。

object born,id:0x237cf30
object born,id:0x237cf58

創建了c1，c2后， 0x237cf30 （c1對應的內存，記為內存1）, 0x237cf58 （c2對應的內存，記為內存2）這兩塊內存的引用計數都是1，執行 c1.t=c2 和 c2.t=c1 后，這兩塊內存的引用計數變成2.

在del c1后，內存1的對象的引用計數變為1，由于不是為0，所以內存1的對象不會被銷毀，所以內存2的對象的引用數依然是2，在del c2后，同理，內存1的對象，內存2的對象的引用數都是1。

雖然它們兩個的對象都是可以被銷毀的，但是由于 循環引用 ，導致垃圾回收器都不會回收它們，所以就會導致內存泄露。

三.垃圾回收

deff3():
    # print gc.collect()
    c1=ClassA()
    c2=ClassA()
    c1.t=c2
    c2.t=c1
    delc1
    delc2
    printgc.garbage
    printgc.collect() #顯式執行垃圾回收
    printgc.garbage
    time.sleep(10)
if __name__ == '__main__':
    gc.set_debug(gc.DEBUG_LEAK) #設置gc模塊的日志
    f3()

輸出：

gc: uncollectable <ClassAinstanceat 0230E918>
gc: uncollectable <ClassAinstanceat 0230E940>
gc: uncollectable <dict 0230B810>
gc: uncollectable <dict 02301ED0>
object born,id:0x230e918
object born,id:0x230e940
4

• 垃圾回收后的對象會放在gc.garbage列表里面
• gc.collect() 會返回 不可達 的對象數目，4等于兩個對象以及它們對應的dict
• 有三種情況會觸發垃圾回收：
  1.調用 gc.collect() ,
  2.當gc模塊的計數器達到閥值的時候。
  3.程序退出的時候

四.gc模塊常用功能解析

Garbage Collector interface

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.set_threshold(threshold0[, threshold1[, threshold2])
   設置自動執行垃圾回收的頻率。
4. gc.get_count()
   獲取當前自動執行垃圾回收的計數器，返回一個長度為3的列表

gc模塊的自動垃圾回收機制

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

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

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

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

gc模塊里面會有一個長度為3的列表的計數器，可以通過 gc.get_count() 獲取。

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

printgc.get_count()  # (590, 8, 0)
a = ClassA()
printgc.get_count()  # (591, 8, 0)
del a
printgc.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)

其他

1. 如果循環引用中，兩個對象都定義了 __del__ 方法，gc模塊不會銷毀這些不可達對象，因為gc模塊不知道應該先調用哪個對象的 __del__ 方法，所以為了安全起見，gc模塊會把對象放到gc.garbage中，但是不會銷毀對象。

五.應用

1. 項目中避免循環引用
2. 引入gc模塊，啟動gc模塊的自動清理循環引用的對象機制
3. 由于分代收集，所以把需要長期使用的變量集中管理，并盡快移到二代以后，減少GC檢查時的消耗
4. gc模塊唯一處理不了的是循環引用的類都有 __del__ 方法，所以項目中要避免定義_ _del__ 方法，如果一定要使用該方法，同時導致了循環引用，需要代碼顯式調用 gc.garbage 里面的對象的 __del__ 來打破僵局

參考：

python的內存管理機制

 

來自：http://python.jobbole.com/87064/