語言的記憶體管理是語言設計的一個重要方面。它是決定語言效能的重要因素。無論是C語言的手工管理，還是Java的垃圾回收，都成為語言最重要的特徵。這裡以Python語言為例子，說明一門動態型別的、物件導向的語言的記憶體管理方式。
物件的記憶體使用
賦值語句是語言最常見的功能了。但即使是最簡單的賦值語句，也可以很有內涵。Python的賦值語句就很值得研究。
|
1 |
a = 1 |
整數1為一個物件。而a是一個引用。利用賦值語句，引用a指向物件1。Python是動態型別的語言(參考動態型別)，物件與引用分離。Python像使用“筷子”那樣，通過引用來接觸和翻動真正的食物——物件。
引用和物件
為了探索物件在記憶體的儲存，我們可以求助於Python的內建函式id()。它用於返回物件的身份(identity)。其實，這裡所謂的身份，就是該物件的記憶體地址。
|
1 2 3 4 |
a = 1 print(id(a)) print(hex(id(a))) |
在我的計算機上，它們返回的是:
11246696
‘0xab9c68’
分別為記憶體地址的十進位制和十六進位制表示。
在Python中，整數和短小的字元，Python都會快取這些物件，以便重複使用。當我們建立多個等於1的引用時，實際上是讓所有這些引用指向同一個物件。
|
1 2 3 4 5 |
a = 1 b = 1 print(id(a)) print(id(b)) |
上面程式返回
11246696
11246696
可見a和b實際上是指向同一個物件的兩個引用。
為了檢驗兩個引用指向同一個物件，我們可以用is關鍵字。is用於判斷兩個引用所指的物件是否相同。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
# True a = 1 b = 1 print(a is b) # True a = "good" b = "good" print(a is b) # False a = "very good morning" b = "very good morning" print(a is b) # False a = [] b = [] print(a is b) |
上面的註釋為相應的執行結果。可以看到，由於Python快取了整數和短字串，因此每個物件只存有一份。比如，所有整數1的引用都指向同一物件。即使使用賦值語句，也只是創造了新的引用，而不是物件本身。長的字串和其它物件可以有多個相同的物件，可以使用賦值語句建立出新的物件。
在Python中，每個物件都有存有指向該物件的引用總數，即引用計數(reference count)。
我們可以使用sys包中的getrefcount()，來檢視某個物件的引用計數。需要注意的是，當使用某個引用作為引數，傳遞給getrefcount()時，引數實際上建立了一個臨時的引用。因此，getrefcount()所得到的結果，會比期望的多1。
|
1 2 3 4 5 6 7 |
from sys import getrefcount a = [1, 2, 3] print(getrefcount(a)) b = a print(getrefcount(b)) |
由於上述原因，兩個getrefcount將返回2和3，而不是期望的1和2。
物件引用物件
Python的一個容器物件(container)，比如表、詞典等，可以包含多個物件。實際上，容器物件中包含的並不是元素物件本身，是指向各個元素物件的引用。
我們也可以自定義一個物件，並引用其它物件:
|
1 2 3 4 5 6 7 8 |
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。
|
1 2 3 4 5 6 7 |
from sys import getrefcount a = [1, 2, 3] print(getrefcount(a)) b = [a, a] print(getrefcount(a)) |
由於物件b引用了兩次a，a的引用計數增加了2。
容器物件的引用可能構成很複雜的拓撲結構。我們可以用objgraph包來繪製其引用關係，比如
|
1 2 3 4 5 6 |
x = [1, 2, 3] y = [x, dict(key1=x)] z = [y, (x, y)] import objgraph objgraph.show_refs([z], filename='ref_topo.png') |
objgraph是Python的一個第三方包。安裝之前需要安裝xdot。
|
1 2 |
sudo apt-get install xdot sudo pip install objgraph |
兩個物件可能相互引用，從而構成所謂的引用環(reference cycle)。
|
1 2 3 |
a = [] b = [a] a.append(b) |
即使是一個物件，只需要自己引用自己，也能構成引用環。
|
1 2 3 |
a = [] a.append(a) print(getrefcount(a)) |
引用環會給垃圾回收機制帶來很大的麻煩，我將在後面詳細敘述這一點。
引用減少
某個物件的引用計數可能減少。比如，可以使用del關鍵字刪除某個引用:
|
1 2 3 4 5 6 7 8 |
from sys import getrefcount a = [1, 2, 3] b = a print(getrefcount(b)) del a print(getrefcount(b)) |
del也可以用於刪除容器元素中的元素，比如:
|
1 2 3 |
a = [1,2,3] del a[0] print(a) |
如果某個引用指向物件A，當這個引用被重新定向到某個其他物件B時，物件A的引用計數減少:
|
1 2 3 4 5 6 7 8 |
from sys import getrefcount a = [1, 2, 3] b = a print(getrefcount(b)) a = 1 print(getrefcount(b)) |
垃圾回收
吃太多，總會變胖，Python也是這樣。當Python中的物件越來越多，它們將佔據越來越大的記憶體。不過你不用太擔心Python的體形，它會乖巧的在適當的時候“減肥”，啟動垃圾回收(garbage collection)，將沒用的物件清除。在許多語言中都有垃圾回收機制，比如Java和Ruby。儘管最終目的都是塑造苗條的提醒，但不同語言的減肥方案有很大的差異 (這一點可以對比本文和Java記憶體管理與垃圾回收
)。
從基本原理上，當Python的某個物件的引用計數降為0時，說明沒有任何引用指向該物件，該物件就成為要被回收的垃圾了。比如某個新建物件，它被分配給某個引用，物件的引用計數變為1。如果引用被刪除，物件的引用計數為0，那麼該物件就可以被垃圾回收。比如下面的表:
|
1 2 |
a = [1, 2, 3] del a |
del a後，已經沒有任何引用指向之前建立的[1, 2, 3]這個表。使用者不可能通過任何方式接觸或者動用這個物件。這個物件如果繼續待在記憶體裡，就成了不健康的脂肪。當垃圾回收啟動時，Python掃描到這個引用計數為0的物件，就將它所佔據的記憶體清空。
然而，減肥是個昂貴而費力的事情。垃圾回收時，Python不能進行其它的任務。頻繁的垃圾回收將大大降低Python的工作效率。如果記憶體中的物件不多，就沒有必要總啟動垃圾回收。所以，Python只會在特定條件下，自動啟動垃圾回收。當Python執行時，會記錄其中分配物件(object allocation)和取消分配物件(object deallocation)的次數。當兩者的差值高於某個閾值時，垃圾回收才會啟動。
我們可以通過gc模組的get_threshold()方法，檢視該閾值:
|
1 2 |
import gc print(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代物件進行更頻繁的掃描。
|
1 2 |
import gc gc.set_threshold(700, 10, 5) |
孤立的引用環
引用環的存在會給上面的垃圾回收機制帶來很大的困難。這些引用環可能構成無法使用，但引用計數不為0的一些物件。
|
1 2 3 4 5 6 |
a = [] b = [a] a.append(b) del a del 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效能的重要一步。