
小许那天写了一个事件监听系统,想让对象在收到事件时被通知,同时又不想因为“被监听”而阻止对象被回收。
他的第一版代码大概是这样:
class EventBus:
def __init__(self):
self.listeners = []
def subscribe(self, listener):
self.listeners.append(listener)
def publish(self, event):
for listener in self.listeners:
listener.on_event(event)跑了一段时间,内存监控报警了。他打开内存分析一看,EventBus.listeners这个列表越来越长。每个注册过监听器的对象,即使业务上早就不再需要了,仍然被listeners这个全局列表强引用着,永远无法被回收。
小许很困惑:“这些对象业务上已经不用了,为什么还占着内存?”
同事看了一眼代码,说:“你的listeners列表是强引用,只要它在,对象就死不了。你需要的不是‘记住所有对象’,而是‘记住还活着的对象’。用weakref。”
小许半信半疑地改成了:
import weakref
class EventBus:
def __init__(self):
self.listeners = []
def subscribe(self, listener):
self.listeners.append(weakref.ref(listener))
def publish(self, event):
alive = []
for ref in self.listeners:
listener = ref()
if listener is not None:
listener.on_event(event)
alive.append(ref)
self.listeners = alive改完之后,业务上不再需要的对象能被正常回收了,listeners里对应的弱引用会变成None,在publish时被顺手清理掉。内存曲线平稳了。
但小许紧接着又踩了第二个坑:他在另一个地方对一个整数用了weakref.ref(42),直接报错:
TypeError: cannot create weak reference to 'int' object他这才意识到:弱引用不是什么对象都能用的。
“原来弱引用不是‘一种更弱的引用’,而是‘一种有条件限制的引用机制’。”
这个认知,就是这篇文章要讲清楚的事:弱引用不增加对象的引用计数,但它只能用于“可弱引用”的对象,而且它随时可能变成None,你必须时刻处理这个可能性。
import weakref
import sys
class User:
def __init__(self, name):
self.name = name
# 强引用
u = User("Alice")
print(sys.getrefcount(u)) # 2(u + getrefcount 临时参数)
# 弱引用
r = weakref.ref(u)
print(sys.getrefcount(u)) # 还是 2,弱引用不增加计数
# 对象还活着,弱引用能拿到对象
print(r()) # <__main__.User object at 0x...>
# 删除强引用
del u
# 对象被回收了,弱引用变成 None
print(r()) # None关键点有两个:
第一,创建弱引用不会增加对象的引用计数。 u的引用计数从创建到del之前,始终是2(u本身 + getrefcount的临时参数),weakref.ref(u)没有让它变成3。这就是“弱”的含义:它指向对象,但不“拥有”对象。
第二,弱引用可能随时变成None。 一旦最后一个强引用消失,对象被回收,弱引用就自动变成None。你拿到弱引用之后,**必须每次都用r()去取对象,并检查是否为None**,不能假设它永远有效。
用一个生活场景来理解。
强引用像你把一本书借回家。书在你手里,别人不能把书拿走销毁,除非你先还回去。只要你没还,这本书就一直在。
弱引用像你在图书馆的索引卡片上记了一个书号。卡片不占着书,书该被借走就被借走,该被销毁就被销毁。你想看书的时候,按书号去查,可能查到,也可能被告知“这本书已经下架了”。
区别一目了然:强引用“拥有”对象,弱引用只是“知道对象在哪”,对象可以随时消失。
要理解弱引用,必须先理解引用计数。
Python的每个对象内部都有一个引用计数器。每当有一个新的引用指向它,计数加一;引用消失,计数减一;计数归零,对象被释放。
a = [1, 2, 3] # 列表的引用计数 = 1
b = a # 引用计数 = 2
del b # 引用计数 = 1
del a # 引用计数 = 0,列表被释放强引用(普通的变量赋值、放进容器、作为参数传递)都会增加引用计数。弱引用不会。weakref.ref(obj)创建的是一个“引用对象”,它记录了obj的地址,但不增加obj的引用计数。
当obj的引用计数归零、被回收时,所有指向它的弱引用会被自动置为None(如果创建时传了回调,回调会被调用)。
这就是弱引用的全部机制。它让你能“观察”一个对象,而不“阻止”它被回收。
weakref.ref()不是万能的。它只能用于支持弱引用的对象。
哪些对象支持?
list、dict、set这些内置类型本身作为类时不行,它们的实例可以)哪些对象不支持?
int、float、str、tuple、bytes、bool、None 这些不可变的内置类型import weakref
weakref.ref(42) # TypeError: cannot create weak reference to 'int' object
weakref.ref("hello") # TypeError: cannot create weak reference to 'str' object
weakref.ref((1, 2)) # TypeError: cannot create weak reference to 'tuple' object
class User: pass
weakref.ref(User()) # 可以为什么这些类型不支持?因为弱引用的实现需要在对象内部预留一个“弱引用列表”的位置,用于在对象销毁时通知所有弱引用。int、str这些类型为了节省内存和提升性能,没有预留这个位置。
这个限制在小许的例子里就体现出来了:他想对一个整数用弱引用,直接报错。
这是最常见、也最危险的坑。
import weakref
class Listener:
def on_event(self):
print("收到事件")
listener = Listener()
r = weakref.ref(listener)
# 某个时刻,listener 被回收了
del listener
# 直接调用,报错
r().on_event() # AttributeError: 'NoneType' object has no attribute 'on_event'弱引用随时可能变成None。每次使用弱引用,都必须先取对象、判断是否为None:
obj = r()
if obj is not None:
obj.on_event()或者用weakref.proxy,它会在对象失效时抛出ReferenceError而不是返回None:
p = weakref.proxy(listener)
# listener 被回收后
p.on_event() # ReferenceError: weakly-referenced object no longer existsproxy的好处是语法上像普通对象,不需要每次r();坏处是失效时抛异常,而不是给你一个可以判断的None。哪种更好取决于你的场景。
class EventBus:
def __init__(self):
self.listeners = []
def subscribe(self, listener):
self.listeners.append(weakref.ref(listener))
def publish(self, event):
for ref in self.listeners:
listener = ref()
if listener:
listener.on_event(event)这段代码能跑,但listeners列表里会积累大量失效的弱引用(对象被回收后,ref()返回None)。每次publish都要遍历这些无效条目,列表越来越长,性能越来越差。
小许的最终版本在publish里顺手清理了失效条目:
def publish(self, event):
alive = []
for ref in self.listeners:
listener = ref()
if listener is not None:
listener.on_event(event)
alive.append(ref)
self.listeners = alive但这种方式只在publish时清理,如果长时间不publish,失效条目会一直堆积。更好的方式是在弱引用失效时自动从列表里移除,这就要用到weakref.ref的回调参数。
weakref.ref(obj, callback)的第二个参数是一个回调函数,当obj被回收时,回调会被调用,参数是这个弱引用对象本身。
import weakref
def on_gone(ref):
print("对象被回收了")
class User:
pass
u = User()
r = weakref.ref(u, on_gone)
del u
# 输出:对象被回收了用回调可以实现“自动清理”的监听器列表:
class EventBus:
def __init__(self):
self.listeners = set()
def subscribe(self, listener):
def cleanup(ref):
self.listeners.discard(ref)
ref = weakref.ref(listener, cleanup)
self.listeners.add(ref)
def publish(self, event):
for ref in list(self.listeners):
listener = ref()
if listener is not None:
listener.on_event(event)对象被回收时,cleanup自动把它对应的弱引用从listeners里删掉。列表里永远只有有效的弱引用,不需要在publish里手动清理。
但这里有一个坑:回调函数本身可能捕获外部对象的强引用,形成新的引用链。如果cleanup是一个闭包,捕获了self(EventBus),那么这个闭包会一直持有EventBus的强引用。如果EventBus本身也应该被回收,这个闭包会阻止它。
解决方式是用weakref.ref(self)在闭包里持弱引用,或者把回调写成不依赖外部状态的纯函数。
cache = {}
cache[some_key] = weakref.ref(42) # TypeErrorint、str、tuple这些不可变类型不支持弱引用。如果你需要对它们做“弱缓存”,没有直接的方案。
一个常见的变通是包装一层:
class Box:
def __init__(self, value):
self.value = value
box = Box(42)
r = weakref.ref(box) # 可以但这样做的意义不大:Box的实例如果被强引用着,42也不会被回收;如果Box被回收,42本来也就没人用了。弱引用解决的是“对象被多个地方引用,但不希望某一方阻止回收”的问题,不可变的小对象通常不需要这个机制。
weakref模块提供了两个容器:WeakValueDictionary和WeakKeyDictionary。
WeakValueDictionary的值是弱引用,值对象被回收时,对应的键值对自动从字典里删除:
import weakref
cache = weakref.WeakValueDictionary()
class Data:
pass
d = Data()
cache["key"] = d
print(len(cache)) # 1
del d
print(len(cache)) # 0,自动删除WeakKeyDictionary的键是弱引用,键对象被回收时,条目自动删除。
这两个容器看起来像“自动清理的缓存”,但有两个坑。
第一,值/键必须是可弱引用的对象。 不能把int、str作为WeakValueDictionary的值。
cache = weakref.WeakValueDictionary()
cache["key"] = 42 # TypeError第二,对象仍然需要有一个强引用“活着”,否则刚放进去就被回收了。
cache = weakref.WeakValueDictionary()
cache["key"] = Data() # 临时对象,放进去后立即被回收
print(len(cache)) # 0,因为没有任何强引用指向 Data()要让WeakValueDictionary有用,你必须保证值对象在别的地方有强引用。它适合的场景是“对象在别处被管理,这里只是做一个不阻碍回收的索引”,而不是“这里就是对象的主要存储位置”。
弱引用常用于打破循环引用。但如果用错了方向,弱引用反而会制造问题。
class Parent:
def __init__(self):
self.child = None
class Child:
def __init__(self, parent):
self.parent = weakref.ref(parent) # 子对象弱引用父对象
parent.child = self # 父对象强引用子对象这是正确的用法:父对象强引用子对象(父拥有子),子对象弱引用父对象(子不拥有父)。父对象被回收时,子对象也会随之被回收;子对象被回收时,父对象不受影响。
如果反过来:
class Child:
def __init__(self, parent):
self.parent = parent # 子对象强引用父对象
parent.child = weakref.ref(self) # 父对象弱引用子对象这在很多场景下会出问题:父对象被回收后,子对象的parent属性还强引用着父对象,父对象不会因为“父对象自己没人用了”而回收——它被子对象强引用着。而子对象如果只被父对象的弱引用指着,可能被回收,然后父对象的弱引用变成None,但父对象本身还活着(被子对象强引用),形成一个“父对象还活着但子对象没了”的状态。
弱引用的方向要和“谁拥有谁”的语义一致。 通常是“生命周期长的一方强引用生命周期短的一方,反过来用弱引用”。
判断标准:
需要拥有对象、控制对象的生命周期:用强引用。普通变量、容器、参数传递默认都是强引用。
需要观察对象,但不想阻止它被回收:用弱引用。典型场景是监听器列表、缓存索引、父子关系中子对父的引用、避免循环引用。
对象有明确的唯一所有者,其他方只是“借用”:所有者强引用,借用的地方弱引用。
对象的生命周期由别处管理,你只是想“如果它还在,就做点什么”:用弱引用,并处理None。
需要缓存,但缓存不应该阻止对象被回收:用WeakValueDictionary,同时确保对象在别处有强引用。
不确定对象是否可弱引用:先试weakref.ref(obj),捕获TypeError,或者检查obj的类型是否在不可弱引用的列表里。
小许最终的事件总线是这样的:
import weakref
class EventBus:
def __init__(self):
self.listeners = set()
def subscribe(self, listener):
def cleanup(ref, bus=weakref.ref(self)):
bus_obj = bus()
if bus_obj is not None:
bus_obj.listeners.discard(ref)
ref = weakref.ref(listener, cleanup)
self.listeners.add(ref)
def publish(self, event):
for ref in list(self.listeners):
listener = ref()
if listener is not None:
listener.on_event(event)监听器用弱引用保存,对象被回收时自动从listeners里删除。cleanup里对self也用了弱引用,避免回调闭包阻止EventBus被回收。
他后来在团队文档里写了一条:“弱引用不增加引用计数,对象可以被正常回收,弱引用自动变None。用弱引用必须每次检查None,不能假设它一直有效。不是所有对象都能弱引用,int、str、tuple这些不行。WeakValueDictionary适合做不阻碍回收的索引,不适合做对象的主要存储。弱引用的方向要和‘谁拥有谁’一致,拥有方强引用,被拥有方对拥有方弱引用。”
这个认知的核心是:弱引用不是“更弱的引用”,而是“一种不同语义的引用”。强引用表达“我拥有它,它不能死”;弱引用表达“我知道它,但它可以死”。用错了语义,要么造成内存泄漏(该弱的地方用了强引用),要么造成对象意外消失(该强的地方用了弱引用)。
记住那个图书馆索引的比喻:强引用是把书借回家,书在你手里谁也拿不走;弱引用是记下书号,书该下架就下架,你想看的时候按书号去查,查不到就是查不到。你要“拥有”还是“知道”,决定了你该用哪种引用。
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。