作者 | 頭文件

來源 | 程序員小灰

Python作爲一個高層次的結合瞭解釋性、編譯性、互動性和麪向對象的腳本語言，與大多數編程語言不同，Python中的變量無需事先申明，變量無需指定類型，程序員無需關心內存管理，Python解釋器給你自動回收。開發人員不用過多的關心內存管理機制，這一切全部由 Python 內存管理器承擔了複雜的內存管理工作。

內存不外乎創建和銷燬兩部分，本文將圍繞Python的內存池和垃圾回收兩部分進行分析。

Python內存池

1、爲什麼要引入內存池（why）

當創建大量消耗小內存的對象時，頻繁調用new/malloc會導致大量的內存碎片，致使效率降低。內存池的作用就是預先在內存中申請一定數量的，大小相等的內存塊留作備用，當有新的內存需求時，就先從內存池中分配內存給這個需求，不夠之後再申請新的內存。這樣做最顯著的優勢就是能夠減少內存碎片，提升效率。

python中的內存管理機制爲Pymalloc

2、內存池是如何工作的（how）

首先，我們看一張CPython(python解釋器)的內存架構圖：

  • Python的對象管理主要位於Level+1~Level+3層

  • Level+3層：對於python內置的對象（比如int,dict等）都有獨立的私有內存池，對象之間的內存池不共享，即int釋放的內存，不會被分配給float使用

  • Level+2層：當申請的內存大小小於256KB時，內存分配主要由 Python 對象分配器（Python’s object allocator）實施

  • Level+1層：當申請的內存大小大於256KB時，由Python原生的內存分配器進行分配，本質上是調用C標準庫中的malloc/realloc等函數

關於釋放內存方面，當一個對象的引用計數變爲0時，Python就會調用它的析構函數。調用析構函數並不意味着最終一定會調用free來釋放內存空間，如果真是這樣的話，那頻繁地申請、釋放內存空間會使Python的執行效率大打折扣。因此在析構時也採用了內存池機制，從內存池申請到的內存會被歸還到內存池中，以避免頻繁地申請和釋放動作。

垃圾回收機制

Python的垃圾回收機制採用引用計數機制爲主，標記-清除和分代回收機制爲輔的策略。其中，標記-清除機制用來解決計數引用帶來的循環引用而無法釋放內存的問題，分代回收機制是爲提升垃圾回收的效率。

1、引用計數

Python通過引用計數來保存內存中的變量追蹤，即記錄該對象被其他使用的對象引用的次數。

Python中有個內部跟蹤變量叫做引用計數器，每個變量有多少個引用，簡稱引用計數。當某個對象的引用計數爲0時，就列入了垃圾回收隊列。

>>> a=[1,2]
>>> import sys
>>> sys.getrefcount(a)  ## 獲取對象a的引用次數
2
>>> b=a
>>> sys.getrefcount(a)
3
>>> del b  ## 刪除b的引用
>>> sys.getrefcount(a)
2
>>> c=list()
>>> c.append(a) ## 加入到容器中
>>> sys.getrefcount(a)
3
>>> del c  ## 刪除容器，引用-1
>>> sys.getrefcount(a)
2
>>> b=a
>>> sys.getrefcount(a)
3
>>> a=[3,4]  ## 重新賦值
>>> sys.getrefcount(a)
2

注意：當把a作爲參數傳遞給getrefcount時，會產生一個臨時的引用，因此得出來的結果比真實情況+1

  • 引用計數增加的情況：

  1. 一個對象被分配給一個新的名字（例如：a=[1,2]）

  2. 將其放入一個容器中（如列表、元組或字典）（例如：c.append(a)）

  • 引用計數減少的情況：

  1. 使用del語句對對象別名顯式的銷燬(例如：del b)

  2. 對象所在的容器被銷燬或從容器中刪除對象（例如：del c ）

  3. 引用超出作用域或被重新賦值（例如：a=[3,4]）

引用計數能夠解決大多數垃圾回收的問題，但是遇到兩個對象相互引用的情況，del語句可以減少引用次數，但是引用計數不會歸0，對象也就不會被銷燬，從而造成了內存泄漏問題。針對該情況，Python引入了標記-清除機制。

2、標記-清除

標記-清除用來解決引用計數機制產生的循環引用，進而導致內存泄漏的問題 。循環引用只有在容器對象纔會產生，比如字典，元組，列表等。

顧名思義，該機制在進行垃圾回收時分成了兩步，分別是：

  • 標記階段，遍歷所有的對象，如果是可達的（reachable），也就是還有對象引用它，那麼就標記該對象爲可達；

  • 清除階段，再次遍歷對象，如果發現某個對象沒有標記爲可達（即爲Unreachable），則就將其回收。

>>> a=[1,2]
>>> b=[3,4]
>>> sys.getrefcount(a)
2
>>> sys.getrefcount(b)
2
>>> a.append(b)
>>> sys.getrefcount(b)
3
>>> b.append(a)
>>> sys.getrefcount(a)
3
>>> del a
>>> del b

  • a引用b,b引用a,此時兩個對象各自被引用了2次（去除getrefcout()的臨時引用）

  • 執行del之後，對象a,b的引用次數都-1，此時各自的引用計數器都爲1，陷入循環引用

  • 標記：找到其中的一端a,因爲它有一個對b的引用，則將b的引用計數-1

  • 標記：再沿着引用到b,b有一個a的引用,將a的引用計數-1，此時對象a和b的引用次數全部爲0，被標記爲不可達（Unreachable）

  • 清除: 被標記爲不可達的對象就是真正需要被釋放的對象

上面描述的垃圾回收的階段，會暫停整個應用程序，等待標記清除結束後纔會恢復應用程序的運行。爲了減少應用程序暫停的時間，Python 通過“分代回收”(Generational Collection)以空間換時間的方法提高垃圾回收效率。

3、分代回收

分代回收是基於這樣的一個統計事實，對於程序，存在一定比例的內存塊的生存週期比較短；而剩下的內存塊，生存週期會比較長，甚至會從程序開始一直持續到程序結束。生存期較短對象的比例通常在 80%～90%之間。因此，簡單地認爲：對象存在時間越長，越可能不是垃圾，應該越少去收集。這樣在執行標記-清除算法時可以有效減小遍歷的對象數，從而提高垃圾回收的速度， 是一種以空間換時間的方法策略 。

Python將所有的對象分爲年輕代（第0代）、中年代（第1代）、老年代（第2代）三代。所有的新建對象默認是 第0代對象。當在第0代的gc掃描中存活下來的對象將被移至第1代，在第1代的gc掃描中存活下來的對象將被移至第2代。

gc掃描次數（第0代>第1代>第2代）

當某一代中被分配的對象與被釋放的對象之差達到某一閾值時，就會觸發當前一代的gc掃描。當某一代被掃描時，比它年輕的一代也會被掃描，因此，第2代的gc掃描發生時，第0，1代的gc掃描也會發生，即爲全代掃描。

>>> import gc
>>> gc.get_threshold() ## 分代回收機制的參數閾值設置
(700, 10, 10)

  • 700=新分配的對象數量-釋放的對象數量，第0代gc掃描被觸發

  • 第一個10：第0代gc掃描發生10次，則第1代的gc掃描被觸發

  • 第二個10：第1代的gc掃描發生10次，則第2代的gc掃描被觸發

4、思考

在標記-清除中，如果對象c也引用a,執行del操作後，會發生什麼？

對象a,b,c的引用關係如下圖所示： 

>>> a=[1,2]
>>> b=[3,4]
>>> c=a
>>> a.append(b)
>>> b.append(a)

  • ref_count表示引用計數

  • 對象a,b,c全部爲reachable

執行del之後，引用關係如下圖所示： 

>>> del a
>>> del b

  • a,b,c的ref_count減1

執行gc掃描

  • 標記: a引用b,將b的refcount減1到0，b引用a,將a的refcount減1到1，將b放在unreachable下。

  • 再循環：因爲a是可達的，所以會遞歸地將從a節點出發可以達到的所有節點標記爲reachable下，即爲： 

  • 清除：unreachable下沒有可清除的對象，因此a,b,c對象不會被清除

總結

總體而言，Python通過內存池來減少內存碎片化，提高執行效率。主要通過引用計數來完成垃圾回收，通過標記-清除解決容器對象循環引用造成的問題，通過分代回收提高垃圾回收的效率。

更多精彩推薦
☞6 年成爲 AIoT 獨角獸，這位 17 年連續創業者是如何做到的？
☞5G 時代，將邊緣計算進行到底！
☞被稱爲“Google 最大黑科技”，開發谷歌大腦，這位 AI 掌門人到底有多牛？
☞Python, C++和Java代碼互翻，Facebook開發首個自監督神經編譯器
☞MongoDB 計劃從“Data Sprawl”中逃脫
☞離岸密碼的未來:概述
點分享點點贊點在看
相關文章