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

简介: 本文通过小许优化事件总线的实战案例,深入解析Python弱引用(`weakref`)的核心机制:它不增加引用计数,对象可被正常回收,弱引用随时可能返回`None`;强调其适用对象限制(如`int`/`str`不可弱引用)、常见陷阱(未检`None`、僵尸引用、循环引用方向错误)及正确用法(回调清理、`WeakValueDictionary`场景)。

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

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

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这个全局列表强引用着,永远无法被回收。

小许很困惑:“这些对象业务上已经不用了,为什么还占着内存?”

代理 IP 使用小技巧 让你的数据抓取效率翻倍 (25).png

同事看了一眼代码,说:“你的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 这些不可变的内置类型
  • 部分C扩展类型

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

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

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 exists

proxy的好处是语法上像普通对象,不需要每次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)在闭包里持弱引用,或者把回调写成不依赖外部状态的纯函数。

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

cache = {}
cache[some_key] = weakref.ref(42)  # TypeError

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

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

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的值是弱引用,值对象被回收时,对应的键值对自动从字典里删除:

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,但父对象本身还活着(被子对象强引用),形成一个“父对象还活着但子对象没了”的状态。

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

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

判断标准:

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

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

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

对象的生命周期由别处管理,你只是想“如果它还在,就做点什么”:用弱引用,并处理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适合做不阻碍回收的索引,不适合做对象的主要存储。弱引用的方向要和‘谁拥有谁’一致,拥有方强引用,被拥有方对拥有方弱引用。”

这个认知的核心是:弱引用不是“更弱的引用”,而是“一种不同语义的引用”。强引用表达“我拥有它,它不能死”;弱引用表达“我知道它,但它可以死”。用错了语义,要么造成内存泄漏(该弱的地方用了强引用),要么造成对象意外消失(该强的地方用了弱引用)。

记住那个图书馆索引的比喻:强引用是把书借回家,书在你手里谁也拿不走;弱引用是记下书号,书该下架就下架,你想看的时候按书号去查,查不到就是查不到。你要“拥有”还是“知道”,决定了你该用哪种引用。

目录
相关文章
|
18天前
|
Linux 开发工具 iOS开发
Codex保姆级教程(下载+安装+登录+使用,含所有版本,2026最新)
Codex是OpenAI推出的开源AI编程智能体,本地运行,可理解整个代码库,支持自然语言指令改代码、执行命令、跑测试、修Bug,兼容Win/macOS/Linux。(239字)
7942 58
|
3天前
|
弹性计算 人工智能 API
Codex超详细入门指南(下载·安装·登录·上手,全版本覆盖,2026最新版)
建议收藏本教程,2026 全年各版本更新随时回来查阅。如果你在搭建过程中遇到任何问题,欢迎结合 阿里云工单系统 提交技术支持请求,或在 阿里云开发者社区 搜索 Codex 相关话题交流。 祝你编码愉快,效率翻倍!
1501 0
|
5天前
|
JSON 前端开发 API
阿里云最新Qwen4-Max大模型介绍:模型定位、特征、能力、适用场景解析
2026 年 11 月 11 日,阿里发布第四代旗舰模型Qwen4-Max预览版,首发千问 AI 平台 Token Plan,并同步接入千问办公、Qoder 等入口。该版本聚焦知识理解、世界感知、编程与 Agentic 四项升级,主打复杂编程、专业办公、前端设计与专业软件操作。预览期至 11 月 25 日 24:00,到期后模型标识下线;限时 2 折、新用户再享 5 折,最低 1 折可体验。
|
19天前
|
JavaScript API iOS开发
DeepSeek Harness下载、安装、配置一篇搞定(2026整理,送常用插件)
DeepSeek Harness(DSH)是DeepSeek于2026年开源的MIT协议AI Agent框架,支持插件化组装模型、工具、沙箱与UI,兼容主流大模型。本文提供免Node.js的桌面端安装包(Win/macOS),含详细图文教程及热门插件推荐。
5704 68
|
6天前
|
云安全 人工智能 安全
|
13天前
|
Linux 开发工具 iOS开发
2026最新codex下载安装保姆级使用教程(下载+安装+登录+使用,含所有历史版本)
本文详解OpenAI Codex国内快速上手指南:提供Win/macOS/Linux全平台免安装包、npm/Homebrew等多方式安装、账号/API Key双登录、简体中文切换,覆盖下载、安装、汉化、使用及高频避坑(如微软商店失败、npm超时等),10分钟即可跑通。
2947 9
|
5天前
|
人工智能 前端开发 API
阿里云Qwen4-Max 大模型详解:定位、特征、能力、适用场景与相对Qwen3-Max差异解析
2026年11月11日,阿里发布第四代旗舰模型Qwen4-Max预览版,首发千问AI平台Token Plan并接入千问办公、Qoder等入口。该版本聚焦知识理解、世界感知、编程与Agentic四项升级,主打复杂编程、专业办公、前端设计与专业软件操作等真实任务。预览期为11月11日10:00至11月25日24:00,仅支持Token Plan调用,到期后模型标识下线;限时2折、新用户再享5折,最低1折可体验。
|
3天前
|
Linux Go 开发工具
手机上跑 DeepSeek 智能体:开源安卓客户端 DSH Go 安装与使用指南
DSH Go 是一款开源安卓客户端,将 DeepSeek Harness 智能体引擎装进手机:免 Root、免 Termux,一键安装即用;支持本机运行(内置 Ubuntu+Node.js)或远程接管电脑会话;具备插话打断、过程折叠、屏幕操控、端到端加密分享等特色功能,真正实现智能体“口袋化”。
2242 0
|
11天前
|
人工智能 安全 API
DeepSeek Harness下载、安装、配置一篇搞定(2026整理,送常用插件)
DeepSeek Harness(dsh)是DeepSeek AI于2026年开源的轻量级Agent运行框架,基于Cordis内核,践行“一切皆插件”理念。支持Web/桌面双端,开箱即用;内置多模型接入、丰富插件生态(超3.5万),适配编程、办公、创作等场景。(239字)
1881 1