Python的垃圾回收機制

時間  2019-12-13
標籤 python 垃圾 回收 機制 欄目 Python 简体版
原文   原文鏈接

Python垃圾回收機制原理理解

如今的高級語言如java，c#等，都採用了垃圾收集機制，而再也不是c，c++裏用戶本身管理維護內存的方式。本身管理內存極其自由，能夠任意申請內存，但如同一把劍，爲大量內存泄露，懸空指針等bug埋下隱患。html

對於一個字符串、列表、類甚至數值都是對象，且定位簡單易用的語言，天然不會讓用戶去處理如何分配回收內存的問題。 python裏也同java同樣採用了垃圾收集機制，不過不同的是，python採用的是引用計數機制爲主，標記-清除和分代收集兩種機制爲輔的策略。 引用計數機制： python裏每個東西都是對象，它們的核心就是一個結構體：PyObjectjava

       typedef struct_object {
            int ob_refcnt;
            struct_typeobject *ob_type;
        }PyObject;
PyObject是每一個對象必有的內容，其中ob_refcnt就是作爲引用計數。當一個對象有新的引用時，它的ob_refcnt就會增長，當引用它的對象被刪除，它的ob_refcnt就會減小
 ** #define Py_INCREF(op)   ((op)->ob_refcnt++)          //增長計數**

 **define Py_DECREF(op)                             //減小計數       **

     if (--(op)->ob_refcnt != 0)    \

         ;        \

     else         \

         __Py_Dealloc((PyObject *)(op))

引用計數爲0時，該對象生命就結束了。 
引用計數機制的優勢： 
一、簡單 
二、實時性：一旦沒有引用，內存就直接釋放了。不用像其餘機制等到特定時機。實時性還帶來一個好處：處理回收內存的時間分攤到了平時。 
引用計數機制的缺點： 
一、維護引用計數消耗資源 
二、循環引用python

list1 = []
list2 = []
list1.append(list2)

list2.append(list1) ， list1與list2相互引用，若是不存在其餘對象對它們的引用，list1與list2的引用計數也仍然爲1，所佔用的內存永遠沒法被回收，這將是致命的。 
對於現在的強大硬件，缺點1尚可接受，可是循環引用致使內存泄露，註定python還將引入新的回收機制。c++

上面說到python裏回收機制是以引用計數爲主，標記-清除和分代收集兩種機制爲輔。c#

一、標記-清除機制

  • 標記-清除機制，顧名思義，首先標記對象（垃圾檢測），而後清除垃圾（垃圾回收）。如圖1：

這裏寫圖片描述

首先初始全部對象標記爲白色，並肯定根節點對象（這些對象是不會被刪除），標記它們爲黑色（表示對象有效）。將有效對象引用的對象標記爲灰色（表示對象可達，安全

但它們所引用的對象還沒檢查），檢查完灰色對象引用的對象後，將灰色標記爲黑色。重複直到不存在灰色節點爲止。最後白色結點都是須要清除的對象。app

二、回收對象的組織

  • 這裏所採用的高級機制做爲引用計數的輔助機制，用於解決產生的循環引用問題。而循環引用只會出如今「內部存在能夠對其餘對象引用的對象」，好比：list，class等。

爲了要將這些回收對象組織起來，須要創建一個鏈表。天然，每一個被收集的對象內就須要多提供一些信息，下面代碼是回收對象裏必然出現的。函數

一個對象的實際結構如圖2：spa

這裏寫圖片描述

經過PyGC_Head的指針將每一個回收對象鏈接起來，造成了一個鏈表，也就是在1裏提到的初始化的全部對象。debug

三、分代技術

  • 分代技術是一種典型的以空間換時間的技術，這也正是java裏的關鍵技術。這種思想簡單點說就是：對象存在時間越長，越可能不是垃圾，應該越少去收集。

這樣的思想，能夠減小標記-清除機制所帶來的額外操做。分代就是將回收對象分紅數個代，每一個代就是一個鏈表（集合），代進行標記-清除的時間與代內對象

存活時間成正比例關係。

從上面代碼能夠看出python裏一共有三代，每一個代的threshold值表示該代最多容納對象的個數。默認狀況下，當0代超過700,或1，2代超過10，垃圾回收機制將觸發。

0代觸發將清理全部三代，1代觸發會清理1,2代，2代觸發後只會清理本身。

下面是一個完整的收集流程：鏈表創建，肯定根節點，垃圾標記，垃圾回收~

一、鏈表創建 
首先，中裏在分代技術說過：0代觸發將清理全部三代，1代觸發會清理1,2代，2代觸發後只會清理本身。在清理0代時，會將三個鏈表（代）連接起來，清理1代的時，會連接1,2兩代。在後面三步，都是針對的這個創建以後的鏈表。

二、肯定根節點 
圖1爲一個例子。list1與list2循環引用，list3與list4循環引用。a是一個外部引用。

這裏寫圖片描述

對於這樣一個鏈表，咱們如何得出根節點呢。python裏是在引用計數的基礎上又提出一個有效引用計數的概念。顧名思義，有效引用計數就是去除循環引用後的計數。

Python垃圾回收機制實際應用 

1、引用計數機制

Python中的垃圾回收是以引用計數爲主，分代收集爲輔。引用計數的缺陷是循環引用的問題。
在Python中，若是一個對象的引用數爲0，Python虛擬機就會回收這個對象的內存。

# -*- coding: utf-8 -*-
'''
# @Datetime: 2019/02/13
# @author: Zhang Yafei
'''

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

if __name__ == "__main__":
    f1()

# 輸出
# object born,id:0x38f0c785f8
# object del,id:0x38f0c785f8
# object born,id:0x38f0c785f8
# object del,id:0x38f0c785f8
# object born,id:0x38f0c785f8
# object del,id:0x38f0c785f8
# object born,id:0x38f0c785f8
# object del,id:0x38f0c785f8
# object born,id:0x38f0c785f8
# object del,id:0x38f0c785f8
# object born,id:0x38f0c785f8

c1=ClassA()會建立一個對象，放在0x237cf58內存中，c1變量指向這個內存，這時候這個內存的引用計數是1
del c1後，c1變量再也不指向0x237cf58內存，因此這塊內存的引用計數減一，等於0，因此就銷燬了這個對象，而後釋放內存。

致使引用計數+1的狀況

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

致使引用計數-1的狀況

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

垃圾回收

  • 當內存中有再也不使用的部分時，垃圾收集器就會把他們清理掉。它會去檢查那些引用計數爲0的對象，而後清除其在內存的空間。固然除了引用計數爲0的會被清除，還有一種狀況也會被垃圾收集器清掉：當兩個對象相互引用時，他們自己其餘的引用已經爲0了。
  • 垃圾回收機制還有一個循環垃圾回收器, 確保釋放循環引用對象(a引用b, b引用a, 致使其引用計數永遠不爲0)。

示例

# -*- coding: utf-8 -*-
'''
# @Datetime: 2019/02/13
# @author: Zhang Yafei
'''
import sys

def func(c):
    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 32
# after a=11 33
# after b=1 34
# in func function 36
# after func(a) 34
# after list1=[a,12,14] 35
# after a=12 34
# after del a 34
# after del b 33
# after del list1 32

 

問題：爲何調用函數會令引用計數+2

 

  • 查看一個對象的引用計數
sys.getrefcount(a)能夠查看a對象的引用計數，可是比正常計數大1，由於調用函數的時候傳入a，這會讓a的引用計數+1

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

import gc

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


def f2():
	while True:
		c1 = Test()
		c2 = Test()
		c1.t = c2
		c2.t = c1
		del c1
		del c2
		# gc.collect()

# gc.disable()
f2()

執行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。
雖然它們兩個的對象都是能夠被銷燬的，可是因爲循環引用，致使垃圾回收器都不會回收它們，因此就會致使內存泄露。

三.垃圾回收

# -*- coding: utf-8 -*-
'''
# @Datetime: 2019/02/13
# @author: Zhang Yafei
'''
import gc
import time

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


def func():
    # print(gc.collect())
    c1=Test()
    c2=Test()
    c1.t=c2
    c2.t=c1
    del c1
    del c2
    print(gc.garbage)
    print(gc.collect()) #顯式執行垃圾回收
    print(gc.garbage)


if __name__ == '__main__':
    gc.set_debug(gc.DEBUG_LEAK) #設置gc模塊的日誌
    func()

輸出：

# object born,id:0xd02c0d9da0
# object born,id:0xd02c0d9e48
# []
# gc: collectable <Test 0x000000D02C0D9DA0>
# gc: collectable <Test 0x000000D02C0D9E48>
# gc: collectable <dict 0x000000D02BE53CA8>
# gc: collectable <dict 0x000000D02BE53EA0>
# gc: collectable <type 0x000000D02A2504B8>
# gc: collectable <tuple 0x000000D02C05D848>
# gc: collectable <type 0x000000D02A24ECB8>
# gc: collectable <tuple 0x000000D02C05D8C8>
# gc: collectable <type 0x000000D02A276948>
# gc: collectable <tuple 0x000000D02C05D908>
# gc: collectable <dict 0x000000D02C05E360>
# gc: collectable <dict 0x000000D02C05E438>
# gc: collectable <dict 0x000000D02C05E510>
# gc: collectable <function 0x000000D02C062D08>
# gc: collectable <function 0x000000D02C062D90>
# gc: collectable <function 0x000000D02C062E18>
# gc: collectable <function 0x000000D02C062EA0>
# gc: collectable <member_descriptor 0x000000D02C05E3A8>
# gc: collectable <member_descriptor 0x000000D02C05E3F0>
# gc: collectable <function 0x000000D02C062F28>
# gc: collectable <function 0x000000D02C063048>
# gc: collectable <function 0x000000D02C0630D0>
# gc: collectable <function 0x000000D02C063158>
# gc: collectable <member_descriptor 0x000000D02C05E480>
# gc: collectable <member_descriptor 0x000000D02C05E4C8>
# gc: collectable <function 0x000000D02C0631E0>
# gc: collectable <function 0x000000D02C063268>
# gc: collectable <function 0x000000D02C0632F0>
# gc: collectable <function 0x000000D02C063378>
# gc: collectable <member_descriptor 0x000000D02C05E5A0>
# gc: collectable <member_descriptor 0x000000D02C05E5E8>
# gc: collectable <member_descriptor 0x000000D02C05E630>
# 32
...　
  • 垃圾回收後的對象會放在gc.garbage列表裏面
  • gc.collect()會返回不可達的對象數目，32等於兩個對象以及它們對應的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分配內存的數目減去釋放內存的數目，注意是內存分配，而不是引用計數的增長。例如：

# -*- coding: utf-8 -*-
'''
# @Datetime: 2019/02/13
# @author: Zhang Yafei
'''
import gc

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


print(gc.get_count()) # (393, 4, 1)
a = Test()
print(gc.get_count())  # (395, 4, 1)
del a
print(gc.get_count())  # (394, 4, 1)

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

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),即檢查1、二代對象的垃圾，並重置計數器爲(0,0,1)
  • 當計數器從(699,9,9)增長到(700,9,9)，gc模塊就會執行gc.collect(2),即檢查1、2、三代對象的垃圾，並重置計數器爲(0,0,0)

其餘

  • 若是循環引用中，兩個對象都定義了__del__方法，gc模塊不會銷燬這些不可達對象，由於gc模塊不知道應該先調用哪一個對象的__del__方法，因此爲了安全起見，gc模塊會把對象放到gc.garbage中，可是不會銷燬對象。

五.應用

  1. 項目中避免循環引用
  2. 引入gc模塊，啓動gc模塊的自動清理循環引用的對象機制
  3. 因爲分代收集，因此把須要長期使用的變量集中管理，並儘快移到二代之後，減小GC檢查時的消耗
  4. gc模塊惟一處理不了的是循環引用的類都有__del__方法，因此項目中要避免定義__del__方法，若是必定要使用該方法，同時致使了循環引用，須要代碼顯式調用gc.garbage裏面的對象的__del__來打破僵局

 

參考：https://www.cnblogs.com/pinganzi/p/6646742.html

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程