Unity移动端性能优化实战：从DrawCall到Addressables的资源加载全攻略

Lee General·2026-09-02·阅读 124 GEO检测（免费）

Unity移动端性能优化资源加载优化

|难度：普通|阅读约 34 分钟

Unity引擎开发游戏的移动端性能优化与资源加载优化：一份商业项目级踩坑与实战总结

在商业项目里谈Unity引擎的移动端性能优化，大多数人并不是从技术选型开始的，而是从线上事故开始的：中低端安卓机一进主城就掉到20帧，UI界面打开瞬间卡顿半秒，内存被资源撑爆被杀后台。我在几个上线项目里用真金白银换来的经验是——性能优化和资源加载优化从来不是后期补救，而是一套从项目立项就要建立的工程体系。这篇总结不聊教科书上的理论，只聊商业项目里真正落地过的东西，重点是Unity引擎在移动端的性能优化思路，以及资源加载优化这条主线的完整方案，适合正在做Unity项目、或者准备把项目往移动端上线后优化一遍的开发者参考。

1. 商业项目性能账：先定基线，再谈优化

1.1 机型和帧率的档位划分：没有基线就没有优化目标

很多Unity项目的性能问题，不是技术解决不了，而是根本没有明确的目标。主程说“我们要优化到60帧”，美术说“画面不能缩水”，策划说“功能都要保留”，最后谁也说服不了谁，优化工作变成一团乱麻。

商业项目的做法是先把设备分成档位，给每一档定出可量化的性能基线。以我经历过的上线项目为例，一般分三档：

档位	代表机型	目标帧率	渲染分辨率	后处理	阴影
旗舰档	iPhone 15 Pro、骁龙8 Gen3机型	60 FPS	原生分辨率	全开	高
中端档	iPhone 11、骁龙7系机型	45~60 FPS	0.8~0.9倍分辨率	只保留必要的	中低
低端档	骁龙6系、海思麒麟7系旧机型	30 FPS	0.7倍分辨率	关闭	关闭或仅人物

这个表必须在项目早期就定下来，并且写进开发规范。后续所有优化决策都以这张表为判断标准：渲染分辨率可以降多少、粒子系统能上多少个、后处理在低端机怎么降级，全部有据可查。否则美术同学拼了命往场景里塞高模和粒子，后期再优化，付出的是好几倍的返工成本。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

1.2 帧预算拆解：16.6毫秒到底花在哪里

60 FPS看起来是每帧16.6毫秒的预算，但商业项目里不能真的把16.6毫秒全部用完。真机上的帧时间波动、系统后台调度、网络波动带来的卡顿，都会占用一部分余量。我的习惯是：目标60 FPS的项目，单帧预算设定在12~14毫秒，留出2~4毫秒余量用于突发加载和系统开销。

在Unity Profiler里，一帧的时间主要花在以下几个环节：

CPU主线程：逻辑Update、渲染命令提交、物理、动画更新
渲染线程：GPU命令的翻译和提交
GPU：实际渲染耗时，包括DrawCall执行、Overdraw、后处理
加载与GC：资源加载、Mono堆内存分配和回收

很多刚接触移动端优化的人只盯着DrawCall，觉得DrawCall降下来了帧率就上去了。实际商业项目中，CPU侧的脚本逻辑、GC分配、资源加载的同步卡顿，往往比DrawCall更致命。一个占用5毫秒的Update循环，比多出20个DrawCall可怕得多。所以帧预算拆解的第一件事，是先用Profiler定位当前项目的瓶颈在CPU还是GPU，再决定优化手段的优先级。

2. 渲染层：先把DrawCall与Overdraw压下来

2.1 DrawCall与合批：先说结论，再用数据说话

移动端的GPU是典型的TBR（Tile-Based Rendering）架构，DrawCall过多会带来严重的CPU提交压力和GPU负载。Unity的合批机制有静态合批、动态合批和SRP Batcher三种，但它们各自有严格的生效条件，商业项目里往往不是“开了就有效”。

动态合批的坑最多。它要求合批的物体使用相同的材质，并且顶点属性格式一致。有些美术同学把两个模型的面数不同、顶点布局不同，明明共用同一个材质，动态合批却始终不生效。更隐蔽的是Scale问题：动态合批对非统一缩放的物体会强行拆批，因为非统一缩放会产生额外的顶点变换数据。一个场景里几十个物体，看起来都是同一个材质，结果因为美术随手把某个物体的Scale调成了(1, 1.2, 1)，整个批次被打散。

我的方案是：移动端项目不要依赖动态合批，优先用SRP Batcher。URP下打开SRP Batcher，对于使用相同Shader变体的材质，可以大幅降低CPU侧的合批开销。同时配合GPU Instancing处理大量重复物体，比如场景里的树木、路灯、NPC，用Instancing可以压到一两个DrawCall。这里贴一段URP中让材质支持GPU Instancing的检查方式：

csharp复制// 运行时检查材质是否启用了GPU Instancing
// 在Inspector中勾选Material的Enable GPU Instancing，或者代码开启
Material mat = renderer.sharedMaterial;
if (mat.enableInstancing == false)
{
    mat.enableInstancing = true;
}

这段代码本身不复杂，但要在项目里排查“为什么Instancing不生效”时，90%的情况是材质没有勾选Enable GPU Instancing，或者Shader本身没有声明Instancing变体。在自定义Shader里需要加上：

hlsl复制#pragma multi_compile_instancing

否则材质界面上的勾选是灰的，Instancing完全没有效果。

2.2 Overdraw：透明物体和粒子是隐形杀手

DrawCall降下来了，GPU却还是很慢，这时候要查Overdraw。Overdraw的意思是同一像素被重复绘制多次，移动端GPU的填充率有限，Overdraw高是卡顿的重要原因。

商业项目里Overdraw最严重的元凶通常是这三类：

大面积半透明UI背景，尤其是一层叠一层的弹窗
粒子系统，特别是持续喷发的半透明粒子
草地、树叶这类带有大量透明纹理的植被

排查方法很简单：在Game视图里把渲染模式切到Wireframe或者使用Frame Debugger，但更直观的是在Scene视图开启Overdraw模式，会看到半透明叠加的区域被标成深红色。中低端机上，把Overdraw高发区域的粒子发射器数量减半、半透明UI层级合并，往往帧率能立刻提升10帧以上。

另外，移动端默认的UI渲染本身会产生大量Overdraw。UGUI的每个UI元素即使是纯色背景，也会占用一个矩形绘制区域。项目里我见过有人把一张半透明黑色背景图叠了三层，每层还带描边和阴影效果，一个简单的弹窗界面硬是画了5次全屏区域。解决这类问题不是靠优化技术，而是靠制定UI制作规范，限制单个界面的全屏背景层数和特效层数。

2.3 移动端Shader与后处理的正确姿态

Shader对移动端性能的影响，往往比模型面数还要致命。原因很简单：GPU的ALU（算术逻辑单元）和纹理采样单元是有限的，Shader里多几条复杂指令，放大到几十万像素上就是成倍的耗时增长。

商业项目里我强烈建议：

不要直接使用Unity内置的Standard Shader，它在移动端的指令数过多，尤其是在没有GPU Skinning支持的旧机型上，计算成本很高
优先使用URP/自定义Shader，且针对移动端做一个Low Quality变体，去掉次表面散射、详细法线、高阶反射等无关紧要的特性
严格控制每个Shader的纹理采样数量，采样数不要超过4张
后处理效果在移动端要非常克制。Bloom在1080P以上分辨率下，降采样次数不够就会导致GPU负载直接翻倍

一个实用技巧：启用URP的RenderScale功能，让整个画面以0.8倍分辨率渲染。这个操作对性能提升非常明显，但画面会略微变糊。可以再结合动态分辨率，在帧率低于目标值时自动降低RenderScale，等帧率恢复再调回去，商业项目里这套策略已经是很常见的手段了。

3. 资源加载：AssetBundle与Addressables的工程取舍

3.1 从资源打包开始：AssetBundle的粒度切分

资源加载优化不是从Load开始的，是从打包策略开始的。AssetBundle打出来碎不碎、依赖关系乱不乱，直接决定了运行时加载和卸载的效率。

商业项目里常见的打包粒度方案是按功能模块切分：

公共资源：Shader、通用材质、公共图集、基础UI，打成一个core bundle，启动时常驻
场景资源：每个场景一个包，包含场景里的模型、贴图、地形
UI资源：按界面系统分组，比如战斗UI、主城UI、背包UI，不要所有UI塞一个包
角色资源：按角色个体分组，包含模型、骨骼、动画、贴图、特效
音频：按语言或按音频类型分组

这里最大的坑是依赖资源重复打进了多个bundle。比如同一个shader被角色A和角色B的bundle各引用一次，构建时如果没做依赖分离，这个shader会被重复打进两个包。运行时加载两个角色，内存里就有两份相同的shader资源。加载阶段不会被立即发现，但内存Profile时你就会看到莫名多出来的重复资源。

解决办法是构建AssetBundle时通过Manifest文件处理好依赖关系。现在用原生AssetBundleBuildPipeline构建的话，可以用BuildAssetBundleOptions.DeterministicAssetBundle加AssetBundleManifest来查依赖关系，但更省心的方案是直接用Addressables，它把依赖管理内置了。

3.2 压缩策略：LZ4和LZMA什么时候用

AssetBundle的压缩格式选择，是很多项目忽视的细节。

压缩格式	包体影响	加载速度	内存表现	适用场景
LZMA	最小	最慢，需要整体解压到内存	解压后占用原始大小内存	首次下载包体、冷门大资源
LZ4	中等	较快，支持按需读取	占用原始大小内存	大多数运行时加载的资源
不压缩	最大	最快	直接映身或读取	启动场景、高频热更资源

移动端游戏的安装包下载阶段，通常用LZMA压缩来减小包体大小。但运行时加载AssetBundle如果还沿用LZMA，就会产生严重的解压卡顿。因为LZMA需要从头到尾把整个bundle解压成一份完整数据才能读取，一个几十MB的场景bundle在低端机上可能要卡几秒。

正确做法是：发布包用LZMA压缩以节省空间和下载流量，游戏首次启动进入本地缓存时，将它转换为LZ4压缩的bundle缓存下来。之后所有运行时的加载都从LZ4缓存中读取，这样一来包体小了，运行时加载速度也不差。

3.3 Addressables还是手写AssetBundle管理：我的取舍

手写AssetBundle管理在中小项目里仍然可行，但它有很重的心智负担：你要自己维护引用计数、依赖加载、卸载时机、路径映射，还要处理各种异常情况。商业项目真的需要把精力放到游戏逻辑上，所以我现在的选择是：新项目优先用Addressables，老项目如果AssetBundle体系已经稳定，不要轻易重构。

Addressables最有价值的地方是三条：

引用计数自动管理，运行时不知道资源什么时候被谁引用时，不容易挂
异步加载API天然适配资源加载优化，支持批量、预加载、远程热更
资源更新流程内置，Catalog和远程Content Delivery整合得比较顺

核心加载和释放的代码长这样：

csharp复制using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

public class CharacterLoader : MonoBehaviour
{
    private AsyncOperationHandle<GameObject> m_Handle;

    public async void LoadCharacter(string address)
    {
        // 每个AsyncOperationHandle都会增加引用计数
        m_Handle = Addressables.LoadAssetAsync<GameObject>(address);
        GameObject go = await m_Handle.Task;

        if (m_Handle.Status == AsyncOperationStatus.Succeeded)
        {
            Instantiate(go, transform);
        }
    }

    private void OnDestroy()
    {
        // 释放引用，Addressables内部引用计数归零时才会真正卸载资源
        if (m_Handle.IsValid())
        {
            Addressables.Release(m_Handle);
        }
    }
}

这个例子简单，但包含了一个重要的纪律：一旦调用了Load，就必须在合适的时机调用Release。Addressables的引用机制做得再好，也挡不住开发者无限Load不Release，那依然是资源泄漏，只是泄漏方式从“显式泄漏”变成了“引用计数异常”。项目里我一般会在资源加载层做二次封装，用一个类统一管理加载请求，记录每个资源的加载来源，排查泄漏时能直接看到是谁拉高了引用计数。

3.4 加载时机与异步化：别让Loading界面背锅

很多时候玩家的卡顿并不是Loading界面里的那条进度条太慢，而是游戏逻辑在加载完成后的一瞬间做了大量同步操作。比如场景加载完成后立刻遍历所有角色初始化、刷一遍任务列表、播放开场动画，这些操作全部挤在同一帧，帧时间瞬间飙到几百毫秒。

资源加载优化的核心思路，是把加载操作从关键路径上移走：

预加载：在玩家停留在上一界面的空档期，提前加载下一界面需要的资源。比如战斗前的主城界面，预加载战斗场景的公共资源和角色模型
分帧加载：一个界面里有几十张图标和贴图，用一个加载队列，每帧只加载若干个资源，而不是一次性全部Load
异步加载：所有资源加载统一走异步接口，绝不在Update或者UI事件回调里用Resources.Load或AssetBundle.LoadFromFile同步操作

分帧加载的简单实现：

csharp复制using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AddressableAssets;

public class StaggeredLoader : MonoBehaviour
{
    private Queue<AssetReference> m_Pending = new Queue<AssetReference>();
    private int m_PerFrameLimit = 2;

    public void Enqueue(IEnumerable<AssetReference> assets)
    {
        foreach (var asset in assets)
        {
            m_Pending.Enqueue(asset);
        }
        StartCoroutine(ProcessQueue());
    }

    private IEnumerator ProcessQueue()
    {
        while (m_Pending.Count > 0)
        {
            // 每帧最多加载m_PerFrameLimit个资源
            for (int i = 0; i < m_PerFrameLimit && m_Pending.Count > 0; i++)
            {
                AssetReference ar = m_Pending.Dequeue();
                ar.LoadAssetAsync<Object>();
            }
            yield return null; // 等下一帧
        }
    }
}

这里有几个要点：加载上限要根据机型动态调整，旗舰机可以一帧加载10个，低端机一帧2个都要谨慎。另外，这些加载出来的资源同样要维护引用计数，分帧加载最忌讳的是加载完没人管，变成一堆无主资源占用内存。

4. 内存与加载的平衡：商业项目最容易翻车的区域

4.1 资源生命周期管理：谁负责加载，谁负责卸载

移动端的内存是紧约束，iOS和Android都在各自的系统机制下积极回收内存。但Unity项目里的内存管理，经常不是“内存不够”而是“内存泄漏后不够”的问题。

商业项目里逃不过去的问题是：一个资源，在什么时候卸载才是安全的？ 场景卸载时？对象销毁时？还是界面关闭时？答案取决于资源的使用范围：

公用资源（core bundle）：从启动常驻到进程退出，不卸载
场景资源：随场景切换卸载，切场景时先卸载旧场景资源再加载新场景
UI资源：随界面打开加载、关闭释放，常驻UI（如主界面底栏）单独管理
角色/特效资源：对象池淘汰时释放，或者按LRU策略释放最久未使用的资源

在代码层面，不要在每个对象Destroy时单独卸载它引用的Asset。比如50个敌人共用同一个小兵模型，每个敌人Destroy时都去Release，引用计数会迅速归零，导致还没来得及销毁完的敌人模型资源被提前卸载，画面里立刻出现粉色或空模型。正确做法是给资源挂一个引用计数器，加一个统一的资源管理器，只有计数器归零时才真正卸载。

4.2 图集与纹理格式：一张图决定几十MB内存

移动端纹理内存的计算公式是：宽 × 高 × 每像素字节数。一张1024×1024的RGBA32纹理，不加压缩就是4MB内存。如果一个UI界面里放了10张这种大小的图，光纹理就40MB了，这在低端机上是不能接受的。

商业项目的标准方案是：

使用ASTC压缩格式（iOS和较新的Android都支持），block大小根据纹理内容选择：UI图用6x6或8x8，背景大图用10x10或12x12
如果项目还有旧设备需要兼容，退而求其次用ETC2
打开Sprite Atlas，把所有UI小图打成图集，减少纹理数量和DrawCall
关闭纹理的Read/Write Enabled选项，这个选项开启后纹理会在内存里保留一份CPU可读副本，内存直接翻倍

图集管理的细节以前写过很多，这里只强调一条：图集和纹理格式一定要在项目初期就定好规范。后期返工改图集是最痛苦的，因为要重新P图、重新调UI坐标、重新跑构建。

4.3 对象池与Mono内存：GC是移动端的慢性病

Mono的GC在移动端是个老大难问题。它的工作原理是在堆内存不足以分配新对象时触发一次全量回收，回收期间所有脚本暂停。暂停时间短则几十毫秒，长则几百毫秒，对应到玩家体验上就是一次明显的卡顿。

优化手段集中在减少堆内存分配：

Update里避免字符串拼接，用StringBuilder或者预分配字符串
避免频繁的LINQ操作，比如List.Where()在内部会分配迭代器对象
避免在频繁调用的函数里创建匿名委托或者闭包
对象池不只是缓存GameObject实例，也要缓存组件数组、List容器等引用类型，避免每帧新建List

用Profiler查看GC Alloc是排查分配最直接的方式，在CPU Usage模块里勾选Deep Profile就能看到每个函数的GC Alloc大小。但Deep Profile本身也会显著影响性能，所以只在真机上的特定版本做，不要一直开着。

5. 真机Profile：一次完整的性能排查链路

5.1 从Unity Profiler到真机数据

编辑器里的Profiler数据看看还行，但不能作为移动端性能的最终标准。编辑器跑在PC上，CPU和GPU都和手机相差悬殊。真机Profile是商业项目里不可跳过的一环。

我的标准链路是：

用Unity Profiler连接真机，Android机启用USB调试，iOS机通过数据线连接Xcode
开启Profiler的CPU、GPU、Memory三个模块
复现目标场景，比如进主城、打开背包、释放大招，记录10秒到30秒的数据
导出Profiler数据文件，保存到项目文档里和优化前做对比

在Android上还可以用ADB命令抓一些系统级的东西，比如帧率和内存：

code复制adb shell dumpsys gfxinfo <packageName> framestats

这个命令能输出逐帧的渲染耗时，能够得到中位数、P95、P99等帧时间指标，比只看平均帧率靠谱得多。

5.2 帧时间曲线与实际卡顿的对应关系

很多项目汇报优化成果时会说“平均帧率从35帧提升到了55帧”，但玩家实际体验还是卡。原因在于平均帧率掩盖了长尾卡顿。比如某一次打开商店界面卡了3秒，但这3秒相对一整局游戏时间来说占比很小，平均帧率几乎看不出变化。

正确的指标是看帧时间曲线和尾延迟：

帧时间的中位数代表整体体验
P95帧时间代表最卡的那5%帧的表现
P99帧时间代表极端卡顿的频率

排查卡顿时要看帧时间曲线上出现的尖峰发生在什么操作之后。是点击了某个按钮？是场景加载了？是GC触发了？把这些尖峰和Profiler里的同步加载、GC Alloc尖刺对应起来，才能定位到具体代码。

5.3 工具链组合：UWA、RenderDoc、Memory Profiler

商业项目里依赖Unity自带的Profiler还不够，因为有的信息它不直接告诉你。比如GPU侧的耗时瓶颈，Profiler虽然能看到GPU耗时，但看不出来是像素着色器慢还是Overdraw多。这时候要上RenderDoc，或者用Imagination的PVRShaderEditor，能逐Pass查看GPU指令数。

内存方面，Unity的Memory Profiler包能把整个托管堆和非托管资源树列出来，逐个资源看尺寸、引用来源。项目里查内存异常，90%的问题靠Memory Profiler和UWA报告都能确认：最占内存的是哪张纹理、是哪个AssetBundle引用了它、这个资源是常驻的还是理论上该被卸载的，一目了然。

UWA报告还有一个价值：它会按项目名把每次测试的历史数据串起来，性能是变好了还是恶化了，前后对比一眼就能看出来。这对项目总监和发行方汇报也很有说服力。

6. 商业项目中的真实踩坑记录

6.1 一个UI界面打开卡了500毫秒：UITexture与九宫格

某个版本优化后，玩家反馈背包界面打开卡顿明显。我用Profiler抓帧发现，打开背包的瞬间有大量UI纹理加载，而且是同步加载到内存。

顺着引用链查下去，原因是一个资深UI同学把背景图直接拖成了一个普通的Image，而且这个Image关闭了图集Sprite packing，图片是单独的一张1024×1024的RGBA32纹理，加载时走了Resources.Load，于是打开界面前必须同步加载4MB数据，还要解压成纹理，这就吃掉了大量帧时间。

修复方案是把这张背景图改成九宫格Sprite并放入图集，同时把加载改成异步预加载。修改后，打开背包的帧时间从500毫秒降到30毫秒以内。这事的教训是：UGUI的Image不要直接挂大图，九宫格自适应背景才是移动端UI的正确姿势。

6.2 Shader变体失控：热更新过后的首局卡顿

上线一个多月后，运营反馈大量玩家在更新版本后首次进入战斗会卡顿2~3秒，但之后就没问题。我们抓了Profiler，发现卡顿来源是Shader编译。关键Shader有几千个变体，首次加载某材质需要编译对应变体，编译期间GPU管线完全阻塞。

排查后发现，之前为了省包体空间开启了Shader的Striping，但Striping的规则配置得太激进，把一些实际运行时会用到的变体也踢掉了，运行时触发的新变体编译。修复方式是重新配置ShaderVariantCollection，把常用变体前置收集到启动阶段或者Loading阶段编译，运行时不再触发编译。另外不要盲目相信默认的Striping规则，要结合实际的Shader使用情况做二次检查。

6.3 清理AssetBundle缓存反而让卡顿更严重

还有个项目做“内存优化”时，在切场景时清掉了所有AssetBundle缓存。结果帧率确实上去了，因为内存占用下来了，但玩家反馈场景切换变慢，而且切换过程中卡顿明显。

根因很清楚：清掉缓存后，每次进场景都要重新从本地磁盘或网络加载bundle，IO耗时比内存消耗还要影响体验。后来改成LRU策略，只释放最长时间未使用的资源，保留最近用过的bundle缓存，同时限制缓存总大小，平衡了内存和加载速度。这个例子说明，性能优化不是指标越极端越好，要找到内存、加载速度、帧率三者之间的平衡点。

踩过这些坑以后，我在项目里定了一条规矩：任何性能优化改动都要带上前后对比数据，不只是平均帧率，还要有P95帧时间、内存峰值、加载耗时三个维度。没有数据支撑的优化，不叫优化，叫玄学。这也是商业项目Unity引擎移动端性能优化最核心的一条经验——所有决策都要建立在可量化的数据上，资源加载优化尤其如此。