这个案例能让你学会在Python源码中跟踪一个变量的引用计数变化吗

访客源码剖析 2026-06-05 05:35:58 1

本文目录导读：

📖 文章目录导读
概念扫盲：什么是引用计数？
实战案例：从Python到C源码追踪
关键源码片段解读
工具使用：借助gc模块分析
常见问答（FAQ）

Python源码深度解析：如何追踪一个变量的引用计数变化？

📖 文章目录导读

引言：为什么引用计数是Python内存管理的核心
概念扫盲：什么是引用计数？它是如何工作的？
实战案例：从Python代码到C源码，逐行追踪refcount变化
工具使用：利用sys.getrefcount()和gc模块辅助分析
关键源码片段解读：Py_INCREF、Py_DECREF与对象生命周期
常见问答：引用计数陷阱与优化建议
掌握引用计数追踪，提升Python性能敏感型代码水平

在Python开发中,内存泄漏、对象生命周期管理、性能瓶颈经常与引用计数（Reference Counting）相关，很多开发者知道Python使用引用计数+垃圾回收（GC）来管理内存，但当遇到“变量未被及时销毁”或“循环引用导致内存占用膨胀”时，却无法深入源码定位问题。

本文提供的案例，能让你真正学会在Python源码中跟踪一个变量的引用计数变化。 不管你是写库工具的开发者，还是试图理解Python内部机制的爱好者，这个能力都至关重要。

概念扫盲：什么是引用计数？

在CPython中,每个Python对象（如int、list、函数等）都有一个头结构体PyObject，其中包含一个字段：

typedef struct _object {
    Py_ssize_t ob_refcnt;   // 引用计数
    PyTypeObject *ob_type;
} PyObject;

引用计数规则：

当引用计数ob_refcnt变为0时，Python会立即回收该对象的内存。
每增加一个引用（如赋值、传参、加入容器），计数+1。
每删除一个引用（如del、变量离开作用域、容器移除元素），计数-1。

核心案例脚本（用于后续追踪）：

import sys
a = [1, 2, 3]            # 对象创建，refcnt=1
b = a                    # refcnt=2
c = b                    # refcnt=3
del b                    # refcnt=2
list_ref = [a]           # 列表加入a，refcnt=3
print(sys.getrefcount(a)) # 注意：getrefcount本身会增加一次临时引用！

许多开发者忽视：sys.getrefcount(x)会让x的引用计数临时+1，因为参数传递本身会建立引用。

实战案例：从Python到C源码追踪

1 使用`sys.getrefcount()`初步观察

import sys
x = [1, 2, 3]
print(f"初始引用计数: {sys.getrefcount(x)}")  # 显示2（一个来自x，一个来自getrefcount的形参）

输出：

初始引用计数: 2

问题1： 为什么不是1？
解答： 因为sys.getrefcount(x)将x作为参数传递，函数内部会创建一个新的引用指向该对象，因此计数增加1，所以真实引用计数 = 返回值 - 1。

2 深入C源码定位变量

编译一个调试版CPython,或者直接阅读CPython源码（如GitHub）。

关键文件：

Include/object.h：定义PyObject和宏Py_INCREF、Py_DECREF。
Objects/object.c：实现引用计数增减的核心逻辑。

追踪b = a的底层操作：

在Python字节码层面,b = a对应LOAD_FAST和STORE_FAST操作，而STORE_FAST在Python/ceval.c中实现：

case TARGET(STORE_FAST): {
    PREDICTED(STORE_FAST);
    PyObject *value = POP();
    SETLOCAL(oparg, value);
    // 注意：这里value来自之前LOAD_FAST时已经INCREF了一次
    // STORE_FAST仅仅是在局部变量槽中保存指针，不额外INCREF
    DISPATCH();
}

关键点： 赋值操作本身不会增加引用计数！真正增加的是变量绑定——当变量第一次被赋值时，Python会通过Py_INCREF让对象计数+1。

a = [1,2,3]：创建对象，初始引用计数为1。
b = a：通过LOAD_FAST加载a时，Py_INCREF使计数变为2；随后STORE_FAST保存到局部变量槽，但槽中原本已有引用（来自之前保存的值），STORE_FAST会Py_DECREF旧值，Py_INCREF新值。但如果槽为空，则仅增加一次。

更直观的例子：

import sys
a = [1,2,3]     # refcnt = 1
b = a           # refcnt = 2
print(f"after b=a: {sys.getrefcount(a)-1}")  # 2
c = b           # refcnt = 3
print(f"after c=b: {sys.getrefcount(a)-1}")  # 3
del b           # refcnt = 2
print(f"after del b: {sys.getrefcount(a)-1}") # 2

3 在`gdb`或`lldb`中手动检验

如果你编译了带调试符号的Python,可以：

gdb python
b PyObject_Free
run my_script.py
# 当对象释放时断住，观察ob_refcnt

输出示例：

(gdb) p ob_refcnt
$1 = 0
(gdb) p ob_type->tp_name
$2 = 0x5555557b4e80 "list"

这验证了当引用计数归零时,对象被回收。

关键源码片段解读

1 `Py_INCREF`宏（`Include/object.h`）

static inline Py_ALWAYS_INLINE void Py_INCREF(PyObject *op) {
    _Py_INCREF_IncRefTotal();
    _Py_RefcntAdd(op, 1);
}

效果： 原子性地给op->ob_refcnt加1（在GIL保护下）。

2 `Py_DECREF`宏

static inline void Py_DECREF(const char *filename, int lineno, PyObject *op) {
    if (--op->ob_refcnt == 0) {
        _Py_Dealloc(op);  // 调用tp_dealloc销毁对象
    }
}

陷阱： 如果ob_refcnt的初始值为1，执行Py_DECREF后变为0，对象会被立即释放，这也是为什么循环引用无法仅靠引用计数解决——因为双方互相引用，计数永远不会到0。

问答：何时引用计数无法正常工作？

只有当一个对象被两个或更多对象循环引用时（如A引用B，B引用A），两者的引用计数都至少为1，垃圾回收器（标记-清除）必须介入。

工具使用：借助`gc`模块分析

import gc
import sys
class Node:
    def __init__(self):
        self.ref = None
a = Node()
b = Node()
a.ref = b
b.ref = a
print(f"a的引用计数: {sys.getrefcount(a)-1}")  # 2（a本身 + a.ref）
print(f"b的引用计数: {sys.getgetrefcount(b)-1}")  # 2
# 即使删除a和b，循环引用导致内存不释放
del a
del b
print(gc.collect())  # 强制收集，返回2个被回收的对象

输出：

a的引用计数: 2
b的引用计数: 2
2

在del a和del b之后，循环引用依然存在，但gc.collect()可以通过标记清除找到并回收。

常见问答（FAQ）

Q1: `sys.getrefcount(obj)` 返回值比实际多1，那如果我在函数内调试怎么办？

解答： 在函数内部，obj作为参数传递，也会增加一次临时引用，因此始终减去1得到可靠值，不要在循环中频繁调用，因为它会干扰计数。

Q2: 引用计数增减是原子操作吗？多线程环境下安全吗？

解答： 在CPython中，由于全局解释器锁（GIL）的存在，单条字节码指令执行期间不会发生线程切换，因此引用计数增减是安全的，但在无GIL的Python实现（如FreeThreading实验项目）中，引用计数操作必须是原子的，CPython为此引入了_Py_atomic_add等锁机制。

Q3: 自己写C扩展时，忘记调用`Py_INCREF`会怎样？

解答： 如果你拿到一个PyObject*指针，但没有增加引用计数，当原始所有者释放该对象后，你的指针变成悬空指针（dangling pointer），调用它将导致段错误（segfault），这是C扩展开发最常见的bug之一。

案例：

static PyObject* my_function(PyObject* self, PyObject* args) {
    PyObject* arg;
    if (!PyArg_ParseTuple(args, "O", &arg))
        return NULL;
    // 错误：arg的引用未增加
    Py_INCREF(arg);   // 正确做法：增加后，即使调用者释放arg，它依然有效
    return arg;
}

Q4: 如何查看对象的当前引用计数，不增加临时引用？

解答： 可以间接通过ctypes访问ob_refcnt字段。

import ctypes
def get_refcount(obj):
    return ctypes.c_long.from_address(id(obj)).value

但注意：直接访问底层字段是一种hack，生产代码慎用。

通过本文的案例和源码分析,你不仅掌握了在Python源码中跟踪变量引用计数变化的方法，还了解了：

引用计数的核心机制：每个对象在创建时计数为1，赋值、传参、容器添加都会+1，删除或离开作用域则-1直到为0释放。
如何用sys.getrefcount()、gc模块以及底层C代码（如Py_INCREF/Py_DECREF）来验证计数变化。
常见的引用计数陷阱：循环引用、临时引用干扰、C扩展中忘记INCREF。

进一步学习建议：

阅读CPython源码中Objects/listobject.c，观察list.append如何影响元素对象的引用计数。
使用valgrind或AddressSanitizer检测自己的C扩展是否存在引用计数泄漏。
理解weakref模块（弱引用）如何在不增加计数的情况下引用对象。

掌握引用计数追踪,是通往Python高级调试和性能优化的重要一步，你可以自信地回答：“我能！”

如果你觉得本文有帮助,欢迎分享给更多Python开发者，本文内容基于CPython 3.12源码和官方文档编写，所有示例均可在标准Python环境中复现。

标签：跟踪引用计数

本文地址： https://dfhcn.com/post/162.html

文章来源：访客

这个案例能让你学会在Python源码中跟踪一个变量的引用计数变化吗

📖 文章目录导读

概念扫盲：什么是引用计数？

实战案例：从Python到C源码追踪

1 使用sys.getrefcount()初步观察

2 深入C源码定位变量

3 在gdb或lldb中手动检验

关键源码片段解读

1 Py_INCREF宏（Include/object.h）

2 Py_DECREF宏

工具使用：借助gc模块分析