学习笔记19 10 月, 2026· 约 18 分钟

Unity 资源与热更

Unity 资源与热更 一、C 代码热更新:HybridCLR 与 ILRuntime 1. 为什么 IL2CPP 原生不支持 C 热更 IL2CPP 是 AOT 后端,打包阶段已经把全部 C 编译成了机器码: 运行时 没有 JIT ,设备端不能把新的 IL 编译成机器码; Assembly.Load() 虽然能加载


Unity 资源与热更

一、C# 代码热更新:HybridCLR 与 ILRuntime

1. 为什么 IL2CPP 原生不支持 C# 热更

IL2CPP 是 AOT 后端,打包阶段已经把全部 C# 编译成了机器码:

  • 运行时没有 JIT,设备端不能把新的 IL 编译成机器码;
  • Assembly.Load() 虽然能加载 dll,但只能拿到元数据,无法执行方法,调用直接抛异常。

所以移动端正式包(iOS / Android 全用 IL2CPP)想改 C# 逻辑,只能借助第三方方案。

对比:Mono 后端原生支持 Assembly.Load() 加载新 dll 并直接执行,可以做 C# 热更;但 Mono 打不了 iOS,移动端商用基本废弃。

2. 两条可行路线

1. HybridCLR

给 IL2CPP 扩展一个 IL 解释器:热更 DLL 保留 IL 字节码,运行时逐条解释执行,不生成机器码,因此不违反苹果禁止 JIT 的规则。

⚠️ HybridCLR 不是开启 JIT,它是解释器。JIT 会生成可执行机器码;解释器只是循环解析 IL 字节码逐条跑,不产生新机器指令,所以 iOS 审核允许。

2. ILRuntime

自己实现一套 C# IL 虚拟机,纯 C# 代码解释执行 IL。

3. 常见误区

  1. ❌ "HybridCLR 开启了 JIT" —— 它是解释器,和 JIT 完全不同。
  2. ❌ "Assembly.Load 在 IL2CPP 下能直接热更" —— 只能加载元数据,方法调用抛异常。

4. 哪些能热更,哪些不能

内容 能否热更 说明
业务层 C# 逻辑 ✅ 可以 放到 HybridCLR 热更 DLL 里
Addressables 资源 / AB 包 ✅ 可以 运行时从 CDN 下载,不属于打包阶段产物
SDK 原生库、AndroidManifest、Info.plist ❌ 不能 属于包本体的 AOT / 原生内容,升级必须重新发版
打包进 APK/IPA 的 AOT 代码 ❌ 不能 打包时已固定

一句话:AOT 代码与原生库锁死在包里;能改的只有解释执行的热更 DLL 和运行时下载的资源。

5. 资源热更(Addressables)

C# 代码之外,资源走另一条链路:

  1. 标记资源为 Addressable,分组;
  2. 构建 Remote 资源包,上传 CDN;
  3. 客户端启动检测 Catalog 版本,对比哈希;
  4. 自动下载变更资源,本地缓存。

6. 整套链路串起来

  1. Unity 内核(C++)负责主循环、渲染物理、管理 GameObject/Component;
  2. 脚本层 C# 通过桥接和内核交互,MonoBehaviour 由 C++ 引擎回调生命周期;
  3. 打包 IL2CPP 全部 AOT 预编译,运行时没有 JIT,无法直接加载新 C# DLL;
  4. 想热更 C# 代码:HybridCLR 增加 IL 解释器,解释执行热更 DLL 的 IL 字节码,业务逻辑跑在解释器上;资源热更用 Addressables / AB 包更新二进制资源。

7. 补充与易错点

  • HybridCLR 需要"补充元数据":AOT 包里不存在的泛型实例(如 List<MyHotfixType>),运行时靠补充 AOT dll 的元数据来"补课",否则会抛 ExecutionEngineException。这一步配置错是最常见的接入失败原因。
  • 解释执行有性能代价:热更代码跑在解释器上,数值密集的逻辑会比 AOT 慢一个量级。热更层适合放业务逻辑,别放每帧跑的循环。
  • 热更 DLL 里不能随便用反射:AOT 侧没有的类型、被裁剪的类型,反射拿不到;这也是要配 link.xml 的原因。
  • ILRuntime 的跨域调用更重:热更域与主工程域之间的调用要经过适配器(CLR 绑定 / 委托绑定),调用频繁时开销明显,需要提前生成绑定代码。
  • 合规是前提:解释器不生成机器码,这是通过 iOS 审核的技术基础;但"能过审"不等于"允许",仍需遵守平台对动态代码的实质要求。
  • 版本要配套:热更 DLL 与 AB 资源、AOT 主包的接口签名必须严格匹配,任何一边改了公共接口都可能运行时崩。

二、资源加载与卸载

1. 核心底层真相

Unity 资源分两类:

  • 源资源:编辑器工程目录下的 .png / .fbx / .prefab,是原始文件;
  • 打包后资源:被序列化的二进制资源文件(AssetBundle)。

所有资源的真正数据都存在 C++ 引擎内存里,C# 只拿到对象代理。 因此:

C# 的 GC 回收引用不会释放底层资源内存,必须靠资源卸载 API 手动管理。

Resources.Load、Addressables、AssetBundle.LoadAsset 做的事其实一样:把磁盘二进制读进 C++ 内存,再给 C# 返回一个对象代理。

2. 四种加载方式

  1. Resources:内置,不推荐做游戏热更;
  2. AssetBundle:底层资源包,老方案;
  3. Addressables:官方新方案,基于 AB 封装,新项目推荐;
  4. 直接读本地文件(File.ReadAllBytes):只适合文本 / 二进制,不能直接读 fbx / prefab。

1. Resources.Load

Resources 是特殊目录,打包时全部打进主包、自动压缩、不支持热更新。

// 加载 Prefab,路径不带后缀
GameObject prefab = Resources.Load<GameObject>("Prefabs/Player");
GameObject go = Instantiate(prefab);

// 加载图片
Texture2D tex = Resources.Load<Texture2D>("Tex/Icon");
  • 路径规则:相对于 Resources/,不带文件后缀;
  • Resources.LoadAll:加载文件夹内全部资源;
  • 卸载:
    • Resources.UnloadUnusedAssets():卸载没有被任何引用占用的资源;
    • Resources.UnloadAsset(tex):卸载指定资源对象。

缺点:

  1. 全部打进安装包,无法热更新;
  2. 不能增量更新,无法单独更新某一个资源;
  3. 无法控制资源依赖关系,容易重复打包。

适用场景:少量固定内置资源、调试。正式游戏不要大量使用。

2. AssetBundle

把资源打成独立二进制包,可以放本地或 CDN,支持热更新;可以拆成多个 Bundle 并管理依赖,一个资源被多个包引用只存一份。

代价是版本、缓存、CRC 校验、依赖关系全部要自己手写。

// 1. 加载 AB 包文件
AssetBundle ab = AssetBundle.LoadFromFile("Assets/AB/test.ab");
// 2. 从包加载资源
GameObject prefab = ab.LoadAsset<GameObject>("Player.prefab");
Instantiate(prefab);
// 3. 卸载 AB 包
ab.Unload(false); // 只卸载 AB 包内存,已加载出来的资源保留
ab.Unload(true);  // 卸载包 + 所有从这个包加载出来的资源对象

关键坑:依赖 Bundle。 如果 A 包资源依赖 B 包里的贴图,必须先加载 B 包再加载 A 包,否则贴图丢失变粉色。原生 AB 需要自己维护依赖表。

缺点:整套版本管理、缓存、下载、哈希校验、依赖管理都要自己写;容易忘记卸载造成内存泄漏。

新项目优先 Addressables,不要裸写 AssetBundle。

3. Addressables

建立在 AssetBundle 之上的高层封装,解决原生 AB 的痛点:

  • 自动处理依赖、缓存、版本对比、增量更新,支持远程 CDN;
  • 用 Address 字符串标记资源,不用关心资源实际存放在哪个 AB 包;
  • 支持本地包 + 远程热更包,是现在商业项目的主流;
  • 编辑器模式可以直接运行,不需要先打 AB,开发效率高。
async Task LoadObj()
{
    var handle = Addressables.LoadAssetAsync<GameObject>("Player");
    await handle.Task;
    GameObject prefab = handle.Result;
    Instantiate(prefab);

    // 用完必须释放句柄!!
    Addressables.Release(handle);
}
模板 vs 实例
  1. LoadAssetAsync 只把预制模板资源加载进内存,不会生成场景里的 GameObject;
  2. Instantiate 才复制模板、生成场景实例对象;
  3. Release(handle) 释放的是模板资源,不会销毁已经 Instantiate 出来的实例;
  4. 实例和模板是两份独立对象,实例不持有模板的资源句柄;
  5. 不建议加载完立刻 Release 模板——频繁 Load/Release 有性能开销,适当缓存句柄更好。

⚠️ Addressables 有引用计数:每次 LoadAssetAsync 都必须配套 Release,计数不归零,底层资源永远不会释放。

4. UnityWebRequest

它不是资源加载 API,而是网络请求,用来下载 AssetBundle 文件,也可以下载图片、文本。

UnityWebRequest req = UnityWebRequestAssetBundle.GetAssetBundle(url);
yield return req.SendWebRequest();
AssetBundle ab = DownloadHandlerAssetBundle.GetContent(req);

UnityWebRequest 本身不加载 prefab,只负责把二进制 AB 数据拿到手。

3. 同步加载 vs 异步加载

  • 同步(Resources.Load / LoadFromFile):主线程立刻读磁盘,大资源必然造成明显卡顿;
  • 异步(Addressables、LoadFromMemoryAsync、UnityWebRequest):磁盘 IO 放后台,主线程不卡帧。

❗不要在 Update 里做同步加载大资源。正式项目尽量全部异步。

4. 卸载:两块内存必须分清

Unity 资源内存分两块:

  1. C++ 引擎资源内存:贴图、模型、Mesh 数据;
  2. C# 托管对象:C# 侧的代理对象。

C# 对象被 GC 回收 ≠ C++ 资源内存被释放。

三种卸载手段:

方式 行为
Resources.UnloadUnusedAssets() 扫描所有资源,没有任何 C# 引用的才会被卸载;异步操作
AssetBundle.Unload(true) 直接销毁这个 AB 加载出来的所有资源
Addressables.Release(handle) 引用计数减一,归零才释放底层资源

经典坑

把贴图赋给 GameObject 的材质,然后丢掉 C# 的贴图引用——此时材质还持有贴图引用,UnloadUnusedAssets 不会卸载它。

5. 资源依赖

以"Prefab 引用一张贴图"为例:

  • 加载 Prefab 时,引擎会自动顺带加载贴图;
  • 卸载 Prefab 时,贴图不会自动卸载,需要 UnloadUnusedAssets / Release 清理。

6. 选型

方案 热更新 打包位置 依赖管理 适用场景
Resources ❌ 不支持 打进主包 自动但不可控 少量固定内置资源
原生 AssetBundle ✅ 支持 独立 ab 文件 需自己维护依赖表 老项目,底层定制
Addressables ✅ 支持 封装 AB,远程 CDN 引擎自动管理 新项目、商业游戏首选

7. 常见误区

  1. ❌ Destroy(gameObject) 会自动释放贴图、模型资源 它只销毁 C++ 场景对象和组件,贴图、Mesh 等资源依旧留在内存,要单独卸载资源。
  2. ❌ C# 变量置 null,资源内存就释放 只是断开 C# 引用;引擎内部的材质、Prefab 实例仍持有资源引用。
  3. ❌ Addressables 不用 Release 引用计数不归零,内存永远不会释放。
  4. ❌ Resources 可以做热更新 全部打进安装包,无法远程更新,只能发商店包。

8. 最佳实践

  1. 正式游戏不要大量使用 Resources;
  2. 新项目优先 Addressables,兼顾本地 + 远程热更;
  3. 大资源全部异步加载,避免主线程卡顿;
  4. 资源用完必须正确卸载,防止内存持续上涨;
  5. 资源和代码版本要配套,避免 DLL 逻辑与 AB 资源版本不匹配报错。

9. 补充与易错点

  • Instantiate 必须在主线程:LoadAssetAsync 可以异步,但拿到模板后的实例化只能在主线程做。异步回调若在线程池线程上,必须切回主线程再实例化,否则直接抛异常。
  • AB 的冗余问题:同一张图被多个 Bundle 引用,默认会各自打一份;要靠依赖分析(相同资源提到公共包)来消除。冗余是包体和内存双杀。
  • AB 的引用计数要自己管:加载了包、加载了资源、实例化了对象,三个层级的生命周期不同;Unload(true) 会把还在用的资源一起销毁,线上表现为"材质变粉"。
  • Addressables 的 Catalog 是热更的入口:UpdateCatalogs / CheckForCatalogUpdates 决定"有没有新版本",GetDownloadSizeAsync 决定"要下多少"。不接这套 API 就只是本地加载。
  • 不要用 Resources 做配置表:文本配置走 TextAsset 放在 Resources 里看着方便,但它会让整个目录被打进包,且无法增量更新。
  • 泄漏排查靠工具:Memory Profiler 能按类型看常驻资源数量,配合 Resources.UnloadUnusedAssets 前后的对比,能定位"谁还持有引用"。
  • 场景卸载不释放资源:SceneManager.UnloadSceneAsync 只销毁场景对象,贴图、Mesh 仍留在内存,之后必须显式卸载。

三、对象池

1. 对象池 ObjectPool

作用

复用GameObject,减少频繁Instantiate/Destroy开销;适合大量重复物体(树、道具)。

核心概念

  1. 初始化预先创建N个对象,SetActive(false)存入Queue队列。
  2. 获取:Dequeue取出,SetActive(true),设置位置旋转。
  3. 归还:不用的物体SetActive(false)重新入队列。
  4. 动态扩容:池子为空时Instantiate新对象。
  5. 最大池上限maxPoolSize:超过上限归还时直接Destroy,防止内存无限膨胀。

缺陷

  1. 如果物体全部不一样(每个Chunk模型纹理不同)对象池收益很小。
  2. 区域切换后,池子残留大量不用对象,占用内存;需要支持缩容策略。
  3. 对象池本身非线程安全;多线程访问需要lock。

注意:对象池存的是GameObject实例,不是Prefab模板资源。

2. 补充与易错点

  • 优先用官方 UnityEngine.Pool.ObjectPool<T>:Unity 2021.1+ 内置泛型对象池,支持 createFunc / actionOnGet / actionOnRelease / actionOnDestroy / collectionCheck,不必自己造。
  • 复用前要重置状态:位置、旋转、速度、动画、粒子、事件订阅、协程,任何残留都会让"回收的对象"表现异常。这也是 actionOnGet 存在的意义。
  • 必须有上限:无上限的池在场景切换后会一直持有旧对象,等于内存泄漏。超限时直接 Destroy。
  • 池化的是实例,不是模板:Instantiate 出来的 GameObject 才能进池;LoadAssetAsync 拿到的模板资源不在池的管理范围。
  • 池不是线程安全的:多线程访问同一池必须加锁;Unity 侧绝大多数情况要求主线程操作,所以通常不需要,但要知道边界。
  • 不要池化"状态复杂且难重置"的对象:UI 面板、带大量子物体的复杂预制体,重置成本可能高于重新创建,池化收益为负。