Python 內存管理大揭祕

前言

語言的內存管理是語言設計的一個重要方面。它是決定語言性能的重要因素。不管是C語言的手工管理，仍是Java的垃圾回收，都成爲語言最重要的特徵。這裏以Python語言爲例子，說明一門動態類型的、面向對象的語言的內存管理方式。

 

對象的內存使用

賦值語句是語言最多見的功能了。但即便是最簡單的賦值語句，也能夠頗有內涵。Python的賦值語句就很值得研究。

a = 1

整數1爲一個對象。而a是一個引用。利用賦值語句，引用a指向對象1。Python是動態類型的語言(參考動態類型)，對象與引用分離。Python像使用「筷子」那樣，經過引用來接觸和翻動真正的食物——對象。

 引用和對象

 

爲了探索對象在內存的存儲，咱們能夠求助於Python的內置函數id()。它用於返回對象的身份(identity)。其實，這裏所謂的身份，就是該對象的內存地址。

a = 1
print(id(a))print(hex(id(a)))

在個人計算機上，它們返回的是:

11246696'0xab9c68'

分別爲內存地址的十進制和十六進制表示。

 

在Python中，整數和短小的字符，Python都會緩存這些對象，以便重複使用。當咱們建立多個等於1的引用時，其實是讓全部這些引用指向同一個對象。

a = 1b = 1
print(id(a))print(id(b))

上面程序返回

1124669611246696

可見a和b其實是指向同一個對象的兩個引用。

 程序運行慢？你怕是寫的假 Python

爲了檢驗兩個引用指向同一個對象，咱們能夠用is關鍵字。is用於判斷兩個引用所指的對象是否相同。

# Truea = 1b = 1print(a is b)
# Truea = "good"b = "good"print(a is b)
# Falsea = "very good morning"b = "very good morning"print(a is b)
# Falsea = []b = []print(a is b)

上面的註釋爲相應的運行結果。能夠看到，因爲Python緩存了整數和短字符串，所以每一個對象只存有一份。好比，全部整數1的引用都指向同一對象。即便使用賦值語句，也只是創造了新的引用，而不是對象自己。長的字符串和其它對象能夠有多個相同的對象，可使用賦值語句建立出新的對象。

 

在Python中，每一個對象都有存有指向該對象的引用總數，即引用計數(reference count)。

程序運行慢？你怕是寫的假 Python

咱們可使用sys包中的getrefcount()，來查看某個對象的引用計數。須要注意的是，當使用某個引用做爲參數，傳遞給getrefcount()時，參數實際上建立了一個臨時的引用。所以，getrefcount()所獲得的結果，會比指望的多1。

from sys import getrefcount
a = [1, 2, 3]print(getrefcount(a))
b = aprint(getrefcount(b))

因爲上述緣由，兩個getrefcount將返回2和3，而不是指望的1和2。

 

對象引用對象

Python的一個容器對象(container)，好比表、詞典等，能夠包含多個對象。實際上，容器對象中包含的並非元素對象自己，是指向各個元素對象的引用。

咱們也能夠自定義一個對象，並引用其它對象:

class from_obj(object):    def __init__(self, to_obj):        self.to_obj = to_obj
b = [1,2,3]a = from_obj(b)print(id(a.to_obj))print(id(b))

能夠看到，a引用了對象b。

 

對象引用對象，是Python最基本的構成方式。即便是a = 1這一賦值方式，其實是讓詞典的一個鍵值"a"的元素引用整數對象1。該詞典對象用於記錄全部的全局引用。該詞典引用了整數對象1。咱們能夠經過內置函數globals()來查看該詞典。

 

當一個對象A被另外一個對象B引用時，A的引用計數將增長1。

from sys import getrefcount
a = [1, 2, 3]print(getrefcount(a))
b = [a, a]print(getrefcount(a))

因爲對象b引用了兩次a，a的引用計數增長了2。

 

容器對象的引用可能構成很複雜的拓撲結構。咱們能夠用objgraph包來繪製其引用關係，好比

x = [1, 2, 3]y = [x, dict(key1=x)]z = [y, (x, y)]
import objgraphobjgraph.show_refs([z], filename='ref_topo.png')

 

 

objgraph是Python的一個第三方包。安裝以前須要安裝xdot。

sudo apt-get install xdotsudo pip install objgraph

objgraph官網：http://mg.pov.lt/objgraph/

 

兩個對象可能相互引用，從而構成所謂的引用環(reference cycle)。

a = []b = [a]a.append(b)

即便是一個對象，只須要本身引用本身，也能構成引用環。

a = []a.append(a)print(getrefcount(a))

引用環會給垃圾回收機制帶來很大的麻煩，我將在後面詳細敘述這一點。

 

引用減小

某個對象的引用計數可能減小。好比，可使用del關鍵字刪除某個引用:

from sys import getrefcount
a = [1, 2, 3]b = aprint(getrefcount(b))
del aprint(getrefcount(b)) 

del也能夠用於刪除容器元素中的元素，好比:

a = [1,2,3]del a[0]print(a)

若是某個引用指向對象A，當這個引用被從新定向到某個其餘對象B時，對象A的引用計數減小:

from sys import getrefcount
a = [1, 2, 3]b = aprint(getrefcount(b))
a = 1print(getrefcount(b)) 

垃圾回收

吃太多，總會變胖，Python也是這樣。當Python中的對象愈來愈多，它們將佔據愈來愈大的內存。不過你不用太擔憂Python的體形，它會乖巧的在適當的時候「減肥」，啓動垃圾回收(garbage collection)，將沒用的對象清除。在許多語言中都有垃圾回收機制，好比Java和Ruby。儘管最終目的都是塑造苗條的提醒，但不一樣語言的減肥方案有很大的差別 。

從基本原理上，當Python的某個對象的引用計數降爲0時，說明沒有任何引用指向該對象，該對象就成爲要被回收的垃圾了。好比某個新建對象，它被分配給某個引用，對象的引用計數變爲1。若是引用被刪除，對象的引用計數爲0，那麼該對象就能夠被垃圾回收。好比下面的表:

a = [1, 2, 3]del a

del a後，已經沒有任何引用指向以前創建的[1, 2, 3]這個表。用戶不可能經過任何方式接觸或者動用這個對象。這個對象若是繼續待在內存裏，就成了不健康的脂肪。當垃圾回收啓動時，Python掃描到這個引用計數爲0的對象，就將它所佔據的內存清空。

 

然而，減肥是個昂貴而費力的事情。垃圾回收時，Python不能進行其它的任務。頻繁的垃圾回收將大大下降Python的工做效率。若是內存中的對象很少，就沒有必要總啓動垃圾回收。因此，Python只會在特定條件下，自動啓動垃圾回收。當Python運行時，會記錄其中分配對象(object allocation)和取消分配對象(object deallocation)的次數。當二者的差值高於某個閾值時，垃圾回收纔會啓動。

咱們能夠經過gc模塊的get_threshold()方法，查看該閾值:

import gcprint(gc.get_threshold())

返回(700, 10, 10)，後面的兩個10是與分代回收相關的閾值，後面能夠看到。700便是垃圾回收啓動的閾值。能夠經過gc中的set_threshold()方法從新設置。

 

咱們也能夠手動啓動垃圾回收，即便用gc.collect()。

 

分代回收

Python同時採用了分代(generation)回收的策略。這一策略的基本假設是，存活時間越久的對象，越不可能在後面的程序中變成垃圾。咱們的程序每每會產生大量的對象，許多對象很快產生和消失，但也有一些對象長期被使用。出於信任和效率，對於這樣一些「長壽」對象，咱們相信它們的用處，因此減小在垃圾回收中掃描它們的頻率。

小傢伙要多檢查

 

Python將全部的對象分爲0，1，2三代。全部的新建對象都是0代對象。當某一代對象經歷過垃圾回收，依然存活，那麼它就被納入下一代對象。垃圾回收啓動時，必定會掃描全部的0代對象。若是0代通過必定次數垃圾回收，那麼就啓動對0代和1代的掃描清理。當1代也經歷了必定次數的垃圾回收後，那麼會啓動對0，1，2，即對全部對象進行掃描。

這兩個次數即上面get_threshold()返回的(700, 10, 10)返回的兩個10。也就是說，每10次0代垃圾回收，會配合1次1代的垃圾回收；而每10次1代的垃圾回收，纔會有1次的2代垃圾回收。

一樣能夠用set_threshold()來調整，好比對2代對象進行更頻繁的掃描。

import gcgc.set_threshold(700, 10, 5)

孤立的引用環

引用環的存在會給上面的垃圾回收機制帶來很大的困難。這些引用環可能構成沒法使用，但引用計數不爲0的一些對象。

a = []b = [a]a.append(b)
del adel b

上面咱們先建立了兩個表對象，並引用對方，構成一個引用環。刪除了a，b引用以後，這兩個對象不可能再從程序中調用，就沒有什麼用處了。可是因爲引用環的存在，這兩個對象的引用計數都沒有降到0，不會被垃圾回收。

孤立的引用環

 

爲了回收這樣的引用環，Python複製每一個對象的引用計數，能夠記爲gc_ref。假設，每一個對象i，該計數爲gc_ref_i。Python會遍歷全部的對象i。對於每一個對象i引用的對象j，將相應的gc_ref_j減1。

 遍歷後的結果

 

在結束遍歷後，gc_ref不爲0的對象，和這些對象引用的對象，以及繼續更下游引用的對象，須要被保留。而其它的對象則被垃圾回收。

 

總結

Python做爲一種動態類型的語言，其對象和引用分離。這與曾經的面向過程語言有很大的區別。爲了有效的釋放內存，Python內置了垃圾回收的支持。Python採起了一種相對簡單的垃圾回收機制，即引用計數，並所以須要解決孤立引用環的問題。Python與其它語言既有共通性，又有特別的地方。對該內存管理機制的理解，是提升Python性能的重要一步。