首页
学习
活动
专区
圈层
工具
发布
社区首页 >专栏 >Python的弱引用把我坑惨了,原来weakref和强引用的区别这么大

Python的弱引用把我坑惨了,原来weakref和强引用的区别这么大

原创
作者头像
风一样的男子
发布于 2026-11-17 13:41:34
发布于 2026-11-17 13:41:34
270
举报
文章被收录于专栏:编程教程编程教程

小许那天写了一个事件监听系统,想让对象在收到事件时被通知,同时又不想因为“被监听”而阻止对象被回收。

他的第一版代码大概是这样:

代码语言:javascript
复制
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。”

小许半信半疑地改成了:

代码语言:javascript
复制
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),直接报错:

代码语言:javascript
复制
TypeError: cannot create weak reference to 'int' object

他这才意识到:弱引用不是什么对象都能用的。

“原来弱引用不是‘一种更弱的引用’,而是‘一种有条件限制的引用机制’。”

这个认知,就是这篇文章要讲清楚的事:弱引用不增加对象的引用计数,但它只能用于“可弱引用”的对象,而且它随时可能变成None,你必须时刻处理这个可能性。

先看一个最直观的对比

代码语言:javascript
复制
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的每个对象内部都有一个引用计数器。每当有一个新的引用指向它,计数加一;引用消失,计数减一;计数归零,对象被释放。

代码语言:javascript
复制
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 这些不可变的内置类型
  • 部分C扩展类型
代码语言:javascript
复制
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这些类型为了节省内存和提升性能,没有预留这个位置。

这个限制在小许的例子里就体现出来了:他想对一个整数用弱引用,直接报错。

坑一:忘记检查 None

这是最常见、也最危险的坑。

代码语言:javascript
复制
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:

代码语言:javascript
复制
obj = r()
if obj is not None:
    obj.on_event()

或者用weakref.proxy,它会在对象失效时抛出ReferenceError而不是返回None:

代码语言:javascript
复制
p = weakref.proxy(listener)
# listener 被回收后
p.on_event()  # ReferenceError: weakly-referenced object no longer exists

proxy的好处是语法上像普通对象,不需要每次r();坏处是失效时抛异常,而不是给你一个可以判断的None。哪种更好取决于你的场景。

坑二:弱引用列表里的“僵尸”条目

代码语言:javascript
复制
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里顺手清理了失效条目:

代码语言:javascript
复制
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被回收时,回调会被调用,参数是这个弱引用对象本身。

代码语言:javascript
复制
import weakref

def on_gone(ref):
    print("对象被回收了")

class User:
    pass

u = User()
r = weakref.ref(u, on_gone)
del u
# 输出:对象被回收了

用回调可以实现“自动清理”的监听器列表:

代码语言:javascript
复制
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)在闭包里持弱引用,或者把回调写成不依赖外部状态的纯函数。

坑三:用 weakref 处理不可弱引用的对象

代码语言:javascript
复制
cache = {}
cache[some_key] = weakref.ref(42)  # TypeError

int、str、tuple这些不可变类型不支持弱引用。如果你需要对它们做“弱缓存”,没有直接的方案。

一个常见的变通是包装一层:

代码语言:javascript
复制
class Box:
    def __init__(self, value):
        self.value = value

box = Box(42)
r = weakref.ref(box)  # 可以

但这样做的意义不大:Box的实例如果被强引用着,42也不会被回收;如果Box被回收,42本来也就没人用了。弱引用解决的是“对象被多个地方引用,但不希望某一方阻止回收”的问题,不可变的小对象通常不需要这个机制。

坑四:WeakValueDictionary 和 WeakKeyDictionary 的误用

weakref模块提供了两个容器:WeakValueDictionary和WeakKeyDictionary。

WeakValueDictionary的值是弱引用,值对象被回收时,对应的键值对自动从字典里删除:

代码语言:javascript
复制
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的值。

代码语言:javascript
复制
cache = weakref.WeakValueDictionary()
cache["key"] = 42  # TypeError

第二,对象仍然需要有一个强引用“活着”,否则刚放进去就被回收了。

代码语言:javascript
复制
cache = weakref.WeakValueDictionary()
cache["key"] = Data()  # 临时对象,放进去后立即被回收
print(len(cache))  # 0,因为没有任何强引用指向 Data()

要让WeakValueDictionary有用,你必须保证值对象在别的地方有强引用。它适合的场景是“对象在别处被管理,这里只是做一个不阻碍回收的索引”,而不是“这里就是对象的主要存储位置”。

坑五:循环引用中的弱引用

弱引用常用于打破循环引用。但如果用错了方向,弱引用反而会制造问题。

代码语言:javascript
复制
class Parent:
    def __init__(self):
        self.child = None

class Child:
    def __init__(self, parent):
        self.parent = weakref.ref(parent)  # 子对象弱引用父对象
        parent.child = self                # 父对象强引用子对象

这是正确的用法:父对象强引用子对象(父拥有子),子对象弱引用父对象(子不拥有父)。父对象被回收时,子对象也会随之被回收;子对象被回收时,父对象不受影响。

如果反过来:

代码语言:javascript
复制
class Child:
    def __init__(self, parent):
        self.parent = parent            # 子对象强引用父对象
        parent.child = weakref.ref(self) # 父对象弱引用子对象

这在很多场景下会出问题:父对象被回收后,子对象的parent属性还强引用着父对象,父对象不会因为“父对象自己没人用了”而回收——它被子对象强引用着。而子对象如果只被父对象的弱引用指着,可能被回收,然后父对象的弱引用变成None,但父对象本身还活着(被子对象强引用),形成一个“父对象还活着但子对象没了”的状态。

弱引用的方向要和“谁拥有谁”的语义一致。 通常是“生命周期长的一方强引用生命周期短的一方,反过来用弱引用”。

什么时候用 weakref,什么时候用强引用?

判断标准:

需要拥有对象、控制对象的生命周期:用强引用。普通变量、容器、参数传递默认都是强引用。

需要观察对象,但不想阻止它被回收:用弱引用。典型场景是监听器列表、缓存索引、父子关系中子对父的引用、避免循环引用。

对象有明确的唯一所有者,其他方只是“借用”:所有者强引用,借用的地方弱引用。

对象的生命周期由别处管理,你只是想“如果它还在,就做点什么”:用弱引用,并处理None。

需要缓存,但缓存不应该阻止对象被回收:用WeakValueDictionary,同时确保对象在别处有强引用。

不确定对象是否可弱引用:先试weakref.ref(obj),捕获TypeError,或者检查obj的类型是否在不可弱引用的列表里。

回到小许的故事

小许最终的事件总线是这样的:

代码语言:javascript
复制
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 删除。

目录
  • 先看一个最直观的对比
  • 弱引用的本质:不增加引用计数
  • 弱引用的一个关键限制:不是所有对象都能弱引用
  • 坑一:忘记检查 None
  • 坑二:弱引用列表里的“僵尸”条目
  • 弱引用回调:对象销毁时自动通知
  • 坑三:用 weakref 处理不可弱引用的对象
  • 坑四:WeakValueDictionary 和 WeakKeyDictionary 的误用
  • 坑五:循环引用中的弱引用
  • 什么时候用 weakref,什么时候用强引用?
  • 回到小许的故事
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档