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))) def f1(): while True: c1=ClassA() del c1

1 2 3 4 5 6 7 8 9 10 11 12 13

#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)))   def f1():     while True:         c1=ClassA()         del c1

執行f1()會迴圈輸出這樣的結果，而且程式佔用的記憶體基本不會變動

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

1 2	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

   def func(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 del list1 print 'after del list1', sys.getrefcount(11) - 1

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

   def func(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 del list1 print 'after del list1', sys.getrefcount(11) - 1

   輸出：

   init 24 after a=11 25 after b=1 26 in func function 28 after func(a) 26 after list1=[a,12,14] 27 after a=12 26 after del a 26 after del b 25 after del list1 24

   1 2 3 4 5 6 7 8 9 10

   init 24 after a=11 25 after b=1 26 in func function 28 after func(a) 26 after list1=[a,12,14] 27 after a=12 26 after del a 26 after del b 25 after del list1 24

   問題：為什麼呼叫函式會令引用計數+2

3. 檢視一個物件的引用計數

sys.getrefcount(a)可以檢視a物件的引用計數，但是比正常計數大1，因為呼叫函式的時候傳入a，這會讓a的引用計數+1

二.迴圈引用導致記憶體洩露

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

1 2 3 4 5 6 7 8 9

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

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

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

1 2	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 del c1 del c2 print gc.garbage print gc.collect() #顯式執行垃圾回收 print gc.garbage time.sleep(10) if __name__ == '__main__': gc.set_debug(gc.DEBUG_LEAK) #設定gc模組的日誌 f3()

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

deff3():     # print gc.collect()     c1=ClassA()     c2=ClassA()     c1.t=c2     c2.t=c1     del c1     del c2     print gc.garbage     print gc.collect() #顯式執行垃圾回收     print gc.garbage     time.sleep(10) if __name__ == '__main__':     gc.set_debug(gc.DEBUG_LEAK) #設定gc模組的日誌     f3()

輸出：

Python

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

1 2 3 4 5 6 7

gc: uncollectable <ClassA instance at 0230E918> gc: uncollectable <ClassA instance at 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分配記憶體的數目減去釋放記憶體的數目，注意是記憶體分配，而不是引用計數的增加。例如：

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)

1 2 3 4 5

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)

其他

1. 如果迴圈引用中，兩個物件都定義了__del__方法，gc模組不會銷燬這些不可達物件，因為gc模組不知道應該先呼叫哪個物件的__del__方法，所以為了安全起見，gc模組會把物件放到gc.garbage中，但是不會銷燬物件。

五.應用

1. 專案中避免迴圈引用
2. 引入gc模組，啟動gc模組的自動清理迴圈引用的物件機制
3. 由於分代收集，所以把需要長期使用的變數集中管理，並儘快移到二代以後，減少GC檢查時的消耗
4. gc模組唯一處理不了的是迴圈引用的類都有__del__方法，所以專案中要避免定義__del__方法，如果一定要使用該方法，同時導致了迴圈引用，需要程式碼顯式呼叫gc.garbage裡面的物件的__del__來打破僵局

參考：

python的記憶體管理機制