Unity资源管理（AssetBundle加载和卸载）及内存管理（内存的申请和释放）

admin • • 游戏开发

一、资源类型及创建/销毁

1.资源类型

GameObject, Transform, Mesh, Texture, Material, Shader, Script和各种其他Assets。

2.资源创建方式

  • 静态引用，在脚本中加一个public GameObject变量，在Inspector面板中拖一个prefab到该变量上，然后在需要引用的地方Instantiate；
  • Resource.Load，资源需要放在Assets/Resources目录下；
  • AssetBundle.Load, Load之后Instantiate。

3. 资源销毁方式

  • GameObject.Destroy(gameObject)，销毁该物体；
  • AssetBundle.Unload(false)，释放AssetBundle文件内存镜像，不销毁Load创建的Assets对象；
  • AssetBundle.Unload(true)，释放AssetBundle文件内存镜像同时销毁所有已经Load的Assets内存镜像；
  • Resources.UnloadAsset(Object)，释放已加载的Asset对象；
  • Resources.UnloadUnusedAssets，释放所有没有引用的Asset对象。

先说下AssetBundle的加载和释放

Unity里有一种静态加载机制和两种动态加载机制，动态加载分别是：一是Resources.Load，一是通过AssetBundle.Load,其实两者本质上我理解没有什么区别。Resources.Load就是从一个缺省打进程序包里的AssetBundle里加载资源，而一般AssetBundle文件需要你自己创建，运行时动态加载，可以指定路径和来源的。静态加载是:通过静态绑定的方法来Instantiate一个资源。
其实场景里所有静态的对象也有这么一个加载过程，只是Unity后台替你自动完成了。
详细说一下细节概念：


AssetBundle运行时加载:
来自文件就用CreateFromFile(注意这种方法只能用于standalone程序）这是最快的加载方法
也可以来自Memory,用CreateFromMemory(byte[]),这个byte[]可以来自文件读取的缓冲，www的下载或者其他可能的方式。
其实WWW的assetBundle就是内部数据读取完后自动创建了一个assetBundle而已
Create完以后，等于把硬盘或者网络的一个文件读到内存一个区域，这时候只是个AssetBundle内存镜像数据块，还没有Assets的概念。


Assets加载:
用AssetBundle.Load(同Resources.Load) 这才会从AssetBundle的内存镜像里读取并创建一个Asset对象，创建Asset对象同时也会分配相应内存用于存放(反序列化)
异步读取用AssetBundle.LoadAsync
也可以一次读取多个用AssetBundle.LoadAll


AssetBundle的释放：
AssetBundle.Unload(flase)是释放AssetBundle文件的内存镜像，不包含Load创建的Asset内存对象。
AssetBundle.Unload(true)是释放那个AssetBundle文件内存镜像和并销毁所有用Load创建的Asset内存对象。
二、Demo测试资源加载与释放
Demo中创建了一个简单场景，场景中创建了一个Empty GameObject，上面挂了一个脚本，在Awake函数中通过协程函数来创建资源，具体的Coroutine函数下面都有。
实验中创建的Prefab是一个坦克车，加入场景中场景内存增加3M左右，同时创建了一个AssetBundle资源供AssetBundle使用。

1. Resources.Load方式加载一个Prefab, 然后Instantiate GameObject

代码如下：
IEnumerator LoadResources()
    {
        // 清除干净以免影响测试结果
        Resources.UnloadUnusedAssets();
        // 等待5秒以看到效果
        yield return new WaitForSeconds(5.0f);
        // 通过Resources.Load加载一个资源
        GameObject tank = Resources.Load("Role/Tank") as GameObject;
        yield return new WaitForSeconds(0.5f);
        // Instantiate一个资源出来
        GameObject tankInst = GameObject.Instantiate(tank, Vector3.zero, Quaternion.identity) as GameObject;
        yield return new WaitForSeconds(0.5f);
        // Destroy一个资源
        GameObject.Destroy(tankInst);
        yield return new WaitForSeconds(0.5f);
        //释放无用资源
        tank = null;
        Resources.UnloadUnusedAssets();
        yield return new WaitForSeconds(0.5f);
    }

统计结果如下：

从这里我们得出如下结论:

  • Resouces.Load一个Prefab相对于Instantiate一个资源来说是相对轻量的一个操作，上述过程中，Resources.Load加载一个Prefab几乎没有消耗内存，而Instantiate消耗了2.5M的资源空间。Resources.Load增加了Mesh和Total Object的数量，而Instantiate增加了GameObjects，Objects In Scene和Total Objects的数量；
  • Destroy一个GameObject之后，内存有所减少，但是比较少，本例中减少了0.6M；Instantiate和Destroy前后Material和Texture没有还原，用以后面继续进行Instantiate之用。

若没有调用Resources.UnloadUnusedAssets，统计结果如下：


得出如下结论：
如果不手动执行Resources.UnloadUnusedAssets，则多余的Mesh，Material和Object不会主动释放。

2. 以AssetBundle.Load的方式加载一个Prefab，然后Instantiate一个GameObject

代码如下：
IEnumerator LoadAssets(string path)
    {
        // 清除干净以免影响测试结果
        Resources.UnloadUnusedAssets();
        // 等待5秒以看到效果
        yield return new WaitForSeconds(5.0f);
        // 创建一个WWW类
        WWW bundle = new WWW(path);
        yield return bundle;
        yield return new WaitForSeconds(0.5f);
        // AssetBundle.Load一个资源
        Object  obj =  bundle.assetBundle.Load("tank");
        yield return new WaitForSeconds(0.5f);
        // Instantiate一个资源出来
        GameObject tankInst = Instantiate(obj) as GameObject;
        yield return new WaitForSeconds(0.5f);
        // Destroy一个资源
        GameObject.Destroy(tankInst);
        yield return new WaitForSeconds(0.5f);
        // Unload Resources
        bundle.assetBundle.Unload(false);
        yield return new WaitForSeconds(0.5f);
        // 释放无用资源
        //obj = null;
        //Resources.UnloadUnusedAssets();
        yield return new WaitForSeconds(0.5f);
    }

统计结果如下：

得出如下结论：
通过WWW Load AssetBundle的方式加载一个资源时会自动加载相应的Mesh，Texture和Material，而通过Resouces.Load方式进行加载只会加载Mesh信息。因此通过AssetBundle方式加载后Instantiate一个资源的内存消耗较小，本例中AssetBundle.Load增加了2.5M的内存，而Instantiate增加了1.1M的内存。相比较Resources.Load后Instantiate的内存增量要小很多。

3. 通过静态绑定的方法来Instantiate一个资源

代码如下：

IEnumerator InstResources()
    {
        Resources.UnloadUnusedAssets();
        yield return new WaitForSeconds(5.0f);
        GameObject inst = GameObject.Instantiate(tank, Vector3.zero, Quaternion.identity) as GameObject;
        yield return new WaitForSeconds(1f);
        GameObject.Destroy(inst);
        yield return new WaitForSeconds(1f);
        //释放无用资源
        tank = null;
        Resources.UnloadUnusedAssets();
        yield return new WaitForSeconds(1f);
    }

统计结果如下：

得出结论如下：
通过静态绑定的方式各种资源的加载顺序和Resources.Load的方式是一样的，一个GameObject创建时，其Component中静态绑定的GameObject只会加载Mesh信息，只有当该GameObject Instantiate出来之后才会加载Texture和Material信息。

三、理论篇
加载资源的过程可以分为两个阶段，第一阶段是使用Resources.Load或者AssetBundle.Load加载各种资源，第二阶段是使用GameObject.Instantiate克隆出一个新的GameObject。Load的资源类型包括GameObject, Transform, Mesh, Texture, Material, Shader和Script等各种资源，但是Resources.Load和AssetBundle.Load是有区别的。使用Resources.Load的时候在第一次Instantiate之前，相应的Asset对象还没有被创建，直到第一次Instantiate时才会真正去读取文件创建这些Assets。它的目的是实现一种OnDemand的使用方式，到该资源真正使用时才会去创建这些资源。而使用AssetBundle.Load方法时，会直接将资源文件读取出来创建这些Assets，因此第一次Instantiate的代价会相对较小。
上述区别可以帮助我们解释为什么发射第一发子弹时有明显的卡顿现象的出现。
然后我们再来了解一下Instantiate的过程。Instantiate的过程是一个对Assets进行Clone（复制）和引用相结合的过程，Clone的过程需要申请内存存放自己的数据，而引用的过程只需要直接一个简单的指针指向一个已经Load的资源即可。例如Transform是通过Clone出来的，Texture和TerrainData是通过引用复制的，而Mesh，Material，PhysicalMaterial和Script是Clone和引用同时存在的。以Script为例，Script分为代码段和数据段，所有需要使用该Script的GameObject使用的代码是一样的，而大家的数据有所区别，因此对数据段需要使用Clone的方式，而对代码段需要使用引用的方式来复制。因此Load操作其实Load一些数据源出来，用于创建新对象时被Clone或者被引用。
然后是销毁资源的过程。当Destory一个GameObject或者其他实例时，只是释放实例中那些Clone出来的Assets，而并不会释放那些引用的Assets，因为Destroy不知道是否有其他人在引用这些Assets。等到场景中没有任何物体引用到这些Assets之后，它们就会成为UnusedAssets，此时可以通过Resources.UnloadUnusedAssets来进行释放。AssetBundle.Unload(false)不行，因为它只会释放文件的内存镜像，不会释放资源；AssetBunde.Unload(true)也不行，因为它是暴力的释放，可能有其他对象在引用其中的Assets，暴力释放可能导致程序错误。
另外需要注意，系统在加载新场景时，所有的内存对象都会被自动销毁，这包括了Resources.Load加载的Assets, 静态绑定的Assets，AssetBundle.Load加载的资源和Instantiate实例化的对象。但是AssetBundle.Load本身的文件内存镜像（用于创建各种Asset）不会被自动销毁，这个必须使用AssetBundle.Unload(false)来进行主动销毁。推荐的做法是在加载完资源后立马调用AssetBunble.Unload(false)销毁文件内存镜像。
下图可以帮助理解内存中的Asset和GameObject的关系。

 

四、案例分析
例子1：
一个常见的错误：你从某个AssetBundle里Load了一个prefab并克隆之：obj = Instantiate(AssetBundle1.Load('MyPrefab”);
这个prefab比如是个npc然后你不需要他的时候你用了：
Destroy(obj);你以为就释放干净了其实这时候只是释放了Clone对象，通过Load加载的所有引用、非引用Assets对象全都静静静的躺在内存里。
这种情况应该在Destroy以后用：AssetBundle1.Unload(true)，彻底释放干净。

如果这个AssetBundle1是要反复读取的 不方便Unload，那可以在Destroy以后用：Resources.UnloadUnusedAssets()把所有和这个npc有关的Asset都销毁。
当然如果这个NPC也是要频繁创建 销毁的 那就应该让那些Assets呆在内存里以加速游戏体验。
由此可以解释另一个之前有人提过的话题：为什么第一次Instantiate一个Prefab的时候都会卡一下，因为在你第一次Instantiate之前，相应的Asset对象还没有被创建，要加载系统内置的AssetBundle并创建Assets,第一次以后你虽然Destroy了，但Prefab的Assets对象都还在内存里，所以就很快了。
例子2：
从磁盘读取一个1.unity3d文件到内存并建立一个AssetBundle1对象 
AssetBundle AssetBundle1 = AssetBundle.CreateFromFile("1.unity3d");
从AssetBundle1里读取并创建一个Texture Asset,把obj1的主贴图指向它
obj1.renderer.material.mainTexture = AssetBundle1.Load("wall") as Texture; 
把obj2的主贴图也指向同一个Texture Asset 
obj2.renderer.material.mainTexture =obj1.renderer.material.mainTexture;
Texture是引用对象，永远不会有自动复制的情况出现(除非你真需要，用代码自己实现copy)，只会是创建和添加引用
如果继续：
AssetBundle1.Unload(true) 那obj1和obj2都变成黑的了，因为指向的Texture Asset没了
如果：
AssetBundle1.Unload(false) 那obj1和obj2不变，只是AssetBundle1的内存镜像释放了 
继续：
Destroy(obj1),//obj1被释放，但并不会释放刚才Load的Texture
如果这时候：
Resources.UnloadUnusedAssets();
不会有任何内存释放 因为Texture asset还被obj2用着
如果
Destroy(obj2)
obj2被释放，但也不会释放刚才Load的Texture
继续
Resources.UnloadUnusedAssets();
这时候刚才load的Texture Asset释放了，因为没有任何引用了
最后CG.Collect();
强制立即释放内存
由此可以引申出论坛里另一个被提了几次的问题，如何加载一堆大图片轮流显示又不爆掉
不考虑AssetBundle，直接用www读图片文件的话等于是直接创建了一个Texture Asset
假设文件保存在一个List里
TLlist fileList;
int n=0;
IEnumerator OnClick()
{
        WWW image = new www(fileList[n++])；
        yield return image;
        obj.mainTexture = image.texture;
        n = (n>=fileList.Length-1)?0:n;
        Resources.UnloadUnusedAssets();
}
这样可以保证内存里始终只有一个巨型Texture Asset资源，也不用代码追踪上一个加载的Texture Asset,但是速度比较慢
或者： 
IEnumerator OnClick()
{
        WWW image = new www(fileList[n++])；
        yield return image;
        Texture tex = obj.mainTexture;
        obj.mainTexture = image.texture;
        n = (n>=fileList.Length-1)?0:n;
        Resources.UnloadAsset(tex);
}
这样卸载比较快

五、总结篇
  • 为了不出现首次Instantiate时卡顿的现象，推荐使用AssetBundle.Load的方式代替Resources.Load的方式来加载资源；
  • 加载完资源后立马调用AssetBunble.Unload(false)释放文件内存镜像，释放AssetBundle文件本身的内存镜像，但不销毁加载的Asset对象。（这样你不用保存AssetBundle的引用并且可以立即释放一部分内存） ；
  • Unity自身没有提供良好的内存申请和释放管理机制，Destroy一个GameObject会马上释放内存而不是进行内部的缓存，因此应用程序对频繁不用的对象如NPC，FX等进行对象池管理是必要的，减少内存申请次数；
  • 如果有Instantiate的对象，用Destroy进行销毁在合适的地方调用Resources.UnloadUnusedAssets,释放已经没有引用的Asset.如果需要立即释放内存加上GC.Collect()，否则内存未必会立即被释放，有时候可能导致内存占用过多而引发异常。这样可以保证内存始终被及时释放，占用量最少。也不需要对每个加载的对象进行引用。

总结一下各种加载和初始化的用法:



AssetBundle.CreateFrom.....：创建一个AssetBundle内存镜像，注意同一个assetBundle文件在没有Unload之前不能再次被使用


WWW.AssetBundle：同上，当然要先new一个再 yield return 然后才能使用


AssetBundle.Load(name)：从AssetBundle读取一个指定名称的Asset并生成Asset内存对象，如果多次Load同名对象，除第一次外都只会返回已经生成的Asset对象，也就是说多次Load一个Asset并不会生成多个副本（singleton）。


Resources.Load(path;name)：同上,只是从默认的位置加载。


Instantiate（object)：Clone一个object的完整结构，包括其所有Component和子物体（详见官方文档）,浅Copy，并不复制所有引用类型。有个特别用法，虽然很少这样用，其实可以用Instantiate来完整的拷贝一个引用类型的Asset,比如Texture等，要拷贝的Texture必须类型设置为Read/Write able。

总结一下各种释放
Destroy:主要用于销毁克隆对象，也可以用于场景内的静态物体，不会自动释放该对象的所有引用。虽然也可以用于Asset,但是概念不一样要小心，如果用于销毁从文件加载的Asset对象会销毁相应的资源文件！但是如果销毁的Asset是Copy的或者用脚本动态生成的，只会销毁内存对象。



AssetBundle.Unload(false):释放AssetBundle文件内存镜像


AssetBundle.Unload(true):释放AssetBundle文件内存镜像同时销毁所有已经Load的Assets内存对象


Reources.UnloadAsset(Object):显式的释放已加载的Asset对象，只能卸载磁盘文件加载的Asset对象


Resources.UnloadUnusedAssets:用于释放所有没有引用的Asset对象


GC.Collect()强制垃圾收集器立即释放内存 Unity的GC功能不算好，没把握的时候就强制调用一下
本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
THE END
分享
二维码
< <上一篇
下一篇>>