#ifndef PyDict_MAXFREELIST
#define PyDict_MAXFREELIST 80
#endif
static PyDictObject *free_list[PyDict_MAXFEELIST];
static int numfree = 0;  //緩存池當(dāng)前存儲的元素個數(shù)

static void
dict_dealloc(PyDictObject *mp)
{  
    //獲取ma_values指針
    PyObject **values = mp->ma_values;
    //獲取ma_keys指針
    PyDictKeysObject *keys = mp->ma_keys;
    Py_ssize_t i, n;

    //因為要被銷毀，所以讓GC不再跟蹤
    PyObject_GC_UnTrack(mp);
    //用于延遲釋放
    Py_TRASHCAN_SAFE_BEGIN(mp)
        
    //調(diào)整引用計數(shù)
    //如果values不為NULL，說明是分離表    
    if (values != NULL) {
    //將指向的value、key的引用計數(shù)減1
    //然后釋放ma_values和ma_keys
        if (values != empty_values) {
            for (i = 0, n = mp->ma_keys->dk_nentries; i < n; i++) {
                Py_XDECREF(values[i]);
            }
            free_values(values);
        }
        DK_DECREF(keys);
    }
    //否則說明是結(jié)合表
    else if (keys != NULL) {
    //結(jié)合表的話，dk_refcnt一定是1
    //此時只需要釋放ma_keys，因為鍵值對全部由它來維護(hù)
    //在DK_DECREF里面，會將每個key、value的引用計數(shù)減1
    //然后釋放ma_keys
        assert(keys->dk_refcnt == 1);
        DK_DECREF(keys);
    }
    //將被銷毀的對象放到緩存池當(dāng)中
    if (numfree < PyDict_MAXFREELIST && Py_TYPE(mp) == &PyDict_Type)
        free_list[numfree++] = mp;
    else
    //如果緩存池已滿，則將釋放內(nèi)存
        Py_TYPE(mp)->tp_free((PyObject *)mp);
    Py_TRASHCAN_SAFE_END(mp)
}

static PyObject *
new_dict(PyDictKeysObject *keys, PyObject **values)
{
    //...
    if (numfree) {
        mp = free_list[--numfree];
    }
    //...
}

d1 = {k: 1 for k in "abcdef"}
d2 = {k: 1 for k in "abcdef"}
print("id(d1):", id(d1))
print("id(d2):", id(d2))
# 放到緩存池的尾部
del d1
del d2
# 緩存池：[d1, d2]

# 從緩存池的尾部獲取
# 顯然id(d3)和上面的id(d2)是相等的
d3 = {k: 1 for k in "abcdefghijk"}
# id(d4)和上面的id(d1)是相等的
d4 = {k: 1 for k in "abcdefghijk"}
print("id(d3):", id(d3))
print("id(d4):", id(d4))
# 輸出結(jié)果
"""
id(d1): 1363335780736
id(d2): 1363335780800
id(d3): 1363335780800
id(d4): 1363335780736
"""

//PyDictObject的緩存池叫 free_list
//PyDictKeysObject的緩存池叫 keys_free_list
//兩者不要搞混了
static PyDictKeysObject *keys_free_list[PyDict_MAXFREELIST];
static int numfreekeys = 0;  //緩存池當(dāng)前存儲的元素個數(shù)

static void
free_keys_object(PyDictKeysObject *keys)
{
    //將每個entry的me_key、me_value的引用計數(shù)減1
    for (i = 0, n = keys->dk_nentries; i < n; i++) {
        Py_XDECREF(entries[i].me_key);
        Py_XDECREF(entries[i].me_value);
    }
#if PyDict_MAXFREELIST > 0
    //將其放在緩存池當(dāng)中
    //當(dāng)緩存池未滿、并且dk_size為8的時候被緩存
    if (keys->dk_size == PyDict_MINSIZE && numfreekeys < PyDict_MAXFREELIST) {
        keys_free_list[numfreekeys++] = keys;
        return;
    }
#endif
    PyObject_FREE(keys);
}

static PyDictKeysObject *new_keys_object(Py_ssize_t size)
{
    PyDictKeysObject *dk;
    Py_ssize_t es, usable;
    //...
    //創(chuàng)建 ma_keys，如果緩存池有可用對象、并且size等于8，
    //那么會從 keys_free_list 中獲取
    if (size == PyDict_MINSIZE && numfreekeys > 0) {
        dk = keys_free_list[--numfreekeys];
    }
    else {
        // 否則malloc重新申請
        dk = PyObject_MALLOC(sizeof(PyDictKeysObject)
                             + es * size
                             + sizeof(PyDictKeyEntry) * usable);
        }
    }
    //...
    return dk;
}

import ctypes
class PyObject(ctypes.Structure):
    _fields_ = [("ob_refcnt", ctypes.c_ssize_t),
                ("ob_type", ctypes.c_void_p)]
class PyDictObject(PyObject):
    _fields_ = [("ma_used", ctypes.c_ssize_t),
                ("ma_version_tag", ctypes.c_uint64),
                ("ma_keys", ctypes.c_void_p),
                ("ma_values", ctypes.c_void_p)]
d1 = {_: 1 for _ in "mnuvwxyz12345"}
print(
    PyDictObject.from_address(id(d1)).ma_keys
)  # 1962690551536
# 鍵值對個數(shù)超過了8，dk_size必然也超過了 8
# 那么當(dāng)銷毀d1的時候，d1.ma_keys不會被緩存
# 而是會直接釋放掉
del d1
d2 = {_: 1 for _ in "a"}
print(
    PyDictObject.from_address(id(d2)).ma_keys
)  # 1962387670624

# d2 的 dk_size 顯然等于 8
# 因此它的 ma_keys 是會被緩存的
del d2
d3 = {_: 1 for _ in "abcdefg"}
print(
    PyDictObject.from_address(id(d3)).ma_keys
)  # 1962699215808
# 盡管 d2 的 ma_keys 被緩存起來了
# 但是 d3 的 dk_size 大于 8
# 因此它不會從緩存池中獲取，而是重新創(chuàng)建
# d4 的 dk_size 等于 8
# 因此它會獲取 d2 被銷毀的 ma_keys
d4 = {_: 1 for _ in "abc"}
print(
    PyDictObject.from_address(id(d4)).ma_keys
)  # 1962387670624