Python 弱引用回调的执行时机陷阱

Python 弱引用的回调函数（__callback__）执行时机有很多微妙之处，以下是主要的陷阱：

1. 不确定的执行时机

import weakref

import gc

class MyClass:

def __del__(self):

print("对象被销毁")

def callback(self, ref):

print("弱引用回调被调用")

obj = MyClass()

ref = weakref.ref(obj, obj.callback) # 注意：这里传递了实例方法

del obj

# 输出可能不会立即出现！

# 可能需要手动触发垃圾回收：

gc.collect() # 这时才会输出

2. 在 __del__之后执行

class Data:

def __init__(self, name):

self.name = name

def __del__(self):

print(f"Data.__del__: {self.name}")

# 此时对象可能已部分销毁

# 访问 self.name 可能不安全！

def callback(ref):

print(f"回调被调用，ref: {ref}")

data = Data("test")

ref = weakref.ref(data, callback)

del data

# 输出顺序：

# 1. Data.__del__: test

# 2. 回调被调用，ref: None

# 注意：回调执行时，对象已完全销毁！

3. 循环引用导致永不执行

import weakref

import gc

class Node:

def __init__(self, name):

self.name = name

self.ref = None # 将存储弱引用

def callback(self, ref):

print(f"回调: {self.name}")

# ❌ 危险：这里还在引用 self！

node = Node("A")

node.ref = weakref.ref(node, node.callback) # 循环引用！

# 即使删除引用，由于循环引用，回调永远不会执行

del node

gc.collect() # 这里不会触发回调！

4. 全局解释器锁（GIL）和线程问题

import weakref

import threading

import time

import gc

def callback(ref):

# 回调在哪个线程执行？

print(f"回调在 {threading.current_thread().name} 执行")

class Target:

pass

def worker():

obj = Target()

ref = weakref.ref(obj, callback)

del obj

# 注意：回调可能在工作线程或垃圾回收线程执行

time.sleep(0.1) # 给 GC 时间

# 创建多个线程

for i in range(3):

t = threading.Thread(target=worker, name=f"Worker-{i}")

t.start()

t.join()

5. 回调中创建新引用导致复活

import weakref

import sys

class Zombie:

instances = [] # 类变量保存引用

def callback(self, ref):

print("回调执行")

Zombie.instances.append(self) # ❌ 使对象复活！

# 这会导致未定义行为

obj = Zombie()

ref = weakref.ref(obj, obj.callback)

print(f"引用计数: {sys.getrefcount(obj)}") # 2

del obj

gc.collect()

# 对象"复活"了，但处于不稳定状态

if Zombie.instances:

print(f"僵尸复活: {Zombie.instances[0]}")

6. 回调中的异常会被静默忽略

import weakref

import gc

def bad_callback(ref):

print("执行回调...")

raise ValueError("回调异常！") # ❌ 异常被静默忽略

print("这行不会执行")

class Target:

pass

obj = Target()

ref = weakref.ref(obj, bad_callback)

# 设置异常钩子来捕获

import sys

def excepthook(exc_type, exc_val, exc_tb):

print(f"捕获到异常: {exc_val}")

sys.excepthook = excepthook

del obj

gc.collect() # 异常被静默丢弃，不会传播！

7. 顺序问题

import weakref

import gc

results = []

def callback1(ref):

results.append(1)

print("回调1")

def callback2(ref):

results.append(2)

print("回调2")

# 创建多个对象

obj1 = object()

obj2 = object()

# 创建弱引用

ref1 = weakref.ref(obj1, callback1)

ref2 = weakref.ref(obj2, callback2)

# 同时删除

del obj1, obj2

# 回调执行顺序不确定！

gc.collect()

print(f"结果顺序: {results}") # 可能是 [1, 2] 或 [2, 1]

8. 最佳实践

import weakref

import sys

from typing import Optional, Callable

class SafeWeakRef:

"""安全的弱引用包装器"""

def __init__(self, obj, callback: Optional[Callable] = None):

self._obj_id = id(obj)

self._callback = callback

# 使用 lambda 避免直接传递方法

def safe_callback(ref):

if self._callback:

try:

# 回调不应依赖对象状态

self._callback(self._obj_id)

except Exception as e:

# 显式处理异常

print(f"弱引用回调异常: {e}", file=sys.stderr)

self._ref = weakref.ref(obj, safe_callback)

def get(self):

return self._ref()

# 使用示例

def my_callback(obj_id):

print(f"对象 {obj_id} 被销毁")

class Resource:

def __init__(self, name):

self.name = name

def __del__(self):

print(f"Resource.__del__: {self.name}")

# 使用

resource = Resource("test")

ref = SafeWeakRef(resource, my_callback)

del resource

gc.collect()

关键陷阱总结：

时机不确定：回调在 GC 运行时才执行，不一定是 del时

对象已死：回调执行时，原始对象已销毁，不能访问其属性

线程问题：回调可能在任意线程执行

静默异常：回调中的异常被丢弃

循环引用阻止回调：包含回调的循环引用会阻止整个环被回收

复活风险：在回调中重新引用对象会导致未定义行为

顺序不确定：多个回调的执行顺序不保证

建议：

避免在弱引用回调中访问对象状态

使用函数而非实例方法作为回调

考虑使用 weakref.finalize()（Python 3.4+），它更可靠

不要在回调中执行关键逻辑，仅用于清理外部资源

ITPub博客

Python 弱引用回调的执行时机陷阱

最新文章