Python C擴展的引用計數問題探討

Python GC機制

對於Python這種高級語言來說，開發者不需要自己管理和維護內存。Python採用了引用計數機制爲主，標記-清除和分代收集兩種機制爲輔的垃圾回收機制。

首先，需要搞清楚變量和對象的關係：

• 變量：通過變量指針引用對象。變量指針指向具體對象的內存空間，取對象的值。
• 對象，類型已知，每個對象都包含一個頭部信息（頭部信息：類型標識符和引用計數器）

引用計數

python裏每一個東西都是對象，它們的核心就是一個結構體：PyObject，其中ob_refcnt就是引用計數。當一個對象有新的引用時，ob_refcnt就會增加，當引用它的對象被刪除，ob_refcnt就會減少。當引用計數爲0時，該對象生命就結束了。

typedef struct_object {
     int ob_refcnt;
     struct_typeobject *ob_type;
} PyObject;

#define Py_INCREF(op)   ((op)->ob_refcnt++) //增加計數
#define Py_DECREF(op) \ //減少計數
    if (--(op)->ob_refcnt != 0) \
        ; \
    else \
        __Py_Dealloc((PyObject *)(op))

可以使用sys.getrefcount()函數獲取對象的引用計數，需要注意的是，使用時會比預期的引用次數多1，原因是調用時會針對於查詢的對象自動產生一個臨時引用。

下面簡單展現一下引用計數的變化過程。

• 一開始創建3個對象，引用計數分別是1。
• 之後將n1指向了新的對象"JKL"，則之前的對象“ABC”的引用計數就變成0了。這時候，Python的垃圾回收器開始工作，將“ABC”釋放。
• 接着，讓n2引用n1。“DEF”不再被引用，“JKL”因爲被n1、n2同時引用，所以引用計數變成了2。

>>> n1 = "ABC"
>>> n2 = "DEF"
>>> n3 = "GHI"
>>> sys.getrefcount(n1)
2
>>> sys.getrefcount(n2)
2
>>> sys.getrefcount(n3)
2
>>> n1 = "JKL"
>>> sys.getrefcount(n1)
2
>>> n2 = n1
>>> sys.getrefcount(n1)
3
>>> sys.getrefcount(n2)
3
>>> sys.getrefcount(n3)
2

優缺點：
優點：實時性好。一旦沒有引用，內存就直接釋放了。實時性還帶來一個好處：處理回收內存的時間分攤到了平時。

缺點：維護引用計數消耗資源；循環引用無法解決。

如下圖，典型的循環引用場景。對象除了被變量引用n1、n2外，還被對方的prev或next指針引用，造成了引用計數爲2。之後n1、n2設成null之後，引用計數仍然爲1，導致對象無法被回收。

標記-清除、分代收集

Python採用標記-清除策略來解決循環引用的問題。但是該機制會導致應用程序卡住，爲了減少程序暫停的時間，又通過“分代回收”(Generational Collection)以空間換時間的方法提高垃圾回收效率。詳見Python垃圾回收機制！非常實用

Python C擴展的引用計數

Python提供了GC機制，保證對象不被使用的時候會被釋放掉，開發者不需要過多關心內存管理的問題。但是當使用C擴展的時候，就不這麼簡單了，必須需要理解CPython的引用計數。

當使用C擴展使用Python時，引用計數會隨着PyObjects的創建自動加1，但是當釋放該PyObjects的時候，我們需要顯示的將PyObjects的引用計數減1，否則會出現內存泄漏。

#include "Python.h"

void print_hello_world(void) {
    PyObject *pObj = NULL;

    pObj = PyBytes_FromString("Hello world\n"); /* Object creation, ref count = 1. */
    PyObject_Print(pLast, stdout, 0);
    Py_DECREF(pObj);    /* ref count becomes 0, object deallocated.
                         * Miss this step and you have a memory leak. */
}

有亮點尤其需要注意：

• PyObjects引用計數爲0後，不能再訪問。類似於C語言free後，不能再訪問對象。
• Py_INCREF、Py_DECREF必須成對出現。類似於C語言malloc、free的關係。

Python有三種引用形式，分別爲 “New”, “Stolen” 和“Borrowed” 引用。

New引用

通過Python C Api創建出的PyObject，調用者對該PyObject具有完全的所有權。一般Python文檔這樣體現：

PyObject* PyList_New(int len)
       Return value: New reference.
       Returns a new list of length len on success, or NULL on failure.

針對於New引用的PyObject，有如下兩種選擇。否則，就會出現內存泄漏。

使用完成後，調用Py_DECREF將其釋放掉。

void MyCode(arguments) {
    PyObject *pyo;
    ...
    pyo = Py_Something(args);
    ...
    Py_DECREF(pyo);
}

將引用通過函數返回值等形式傳遞給上層調用函數，但是接收者必須負責最終的Py_DECREF調用。

void MyCode(arguments) {
    PyObject *pyo;
    ...
    pyo = Py_Something(args);
    ...
    return pyo;
}

使用樣例：

static PyObject *subtract_long(long a, long b) {
    PyObject *pA, *pB, *r;

    pA = PyLong_FromLong(a);        /* pA: New reference. */
    pB = PyLong_FromLong(b);        /* pB: New reference. */
    r = PyNumber_Subtract(pA, pB);  /*  r: New reference. */
    Py_DECREF(pA);                  /* My responsibility to decref. */
    Py_DECREF(pB);                  /* My responsibility to decref. */
    return r;                       /* Callers responsibility to decref. */
}

// 錯誤的例子，a、b兩個PyObject泄漏。
r = PyNumber_Subtract(PyLong_FromLong(a), PyLong_FromLong(b));

Stolen引用

當創建的PyObject傳遞給其他的容器，例如PyTuple_SetItem、PyList_SetItem。

static PyObject *make_tuple(void) {
    PyObject *r;
    PyObject *v;

    r = PyTuple_New(3);         /* New reference. */
    v = PyLong_FromLong(1L);    /* New reference. */
    /* PyTuple_SetItem "steals" the new reference v. */
    PyTuple_SetItem(r, 0, v);
    /* This is fine. */
    v = PyLong_FromLong(2L);
    PyTuple_SetItem(r, 1, v);
    /* More common pattern. */
    PyTuple_SetItem(r, 2, PyUnicode_FromString("three"));
    return r; /* Callers responsibility to decref. */
}

但是，需要注意PyDict_SetItem內部會引用計數加一。

Borrowed引用

Python文檔中，Borrowed引用的體現：

PyObject* PyTuple_GetItem(PyObject *p, Py_ssize_t pos) 
Return value: Borrowed reference.

Borrowed 引用的所有者不應該調用 Py_DECREF()，使用Borrowed 引用在函數退出時不會出現內存泄露。。但是不要讓一個對象處理未保護的狀態Borrowed 引用，如果對象處理未保護狀態，它隨時可能會被銷燬。

例如：從一個 list 獲取對象，繼續操作它，但並不遞增它的引用。PyList_GetItem 會返回一個 borrowed reference ，所以 item 處於未保護狀態。一些其他的操作可能會從 list 中將這個對象刪除（遞減它的引用計數，或者釋放它），導致 item 成爲一個懸垂指針。

bug(PyObject *list) {
    PyObject *item = PyList_GetItem(list, 0);
    PyList_SetItem(list, 1, PyInt_FromLong(0L));
    PyObject_Print(item, stdout, 0); /* BUG! */
}

no_bug(PyObject *list) {
    PyObject *item = PyList_GetItem(list, 0);
    Py_INCREF(item); /* Protect item. */
    PyList_SetItem(list, 1, PyInt_FromLong(0L));
    PyObject_Print(item, stdout, 0);
    Py_DECREF(item);
}