unity内存优化之AB包篇（微信小游戏）_unity 微信小游戏

作者：我家自动化 | 2024-05-06 22:19:03

踩

unity 微信小游戏

1.搭建资源服务器使用(HFS软件(https://www.pianshen.com/article/54621708008/))


using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
using System;
 
public class Singleton<T> where T : class, new()
{
    private static readonly Lazy<T> lazy = new Lazy<T>(() => new T());
    public static T Instance { get { return lazy.Value; } }
    protected Singleton() { }
}
 
public class MonoSingleton<T> : MonoBehaviour where T : MonoBehaviour
{
 
    private static T _instance;
 
    public static T Instance
    {
        get
        {
            return _instance;
        }
    }
 
    protected virtual void Awake()
    {
        _instance = this as T;
    }
}

2.核心代码


using Cysharp.Threading.Tasks;
using System.Collections;
using System.Collections.Generic;
using System.Xml.Linq;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.U2D;
 
 
 
/*
内存优化之AB包篇（微信小游戏）
问题：如何优化AB包占用的内存，游戏的AB包资源卸载策略是什么
答：卸载时机
1.该AB包被引用次数为0时候，此时缓存一定的时间，当缓存时间为0时，就可以调用bundle.Unload(true);
缓存时间内被调用重置缓存时间，引用次数增加。
这部分主要用来处理偶尔打开的界面
2.首先维护一个已经加载的AB包资源大小总值，然后设置一个内存基准值，当总值大于内存基准值的时候，
此时去卸载那些引用次数为0的ab资源（优先卸载加载早的ab包资源）。
这部分用来处理短时间内，玩家打开过多大型界面场景，如果不这么处理，手机内存会占用高且发热会严重。
引用次数的维护时机（引用次数始终不小于0）
1.例如一张图片 更换属于不同ab包的资源图片时，需要先将旧的ab包  引用次数减一，界面销毁时，最后动态加载的ab图片资源也需要减一，其他资源同理
2.同时加载一个AB资源时，在AB资源未加载完毕前，需要维护一个加载中的AB包资源实际被加载次数，
由于部分界面 正在动态加载的ab包资源未加载完毕时，此界面就可能已经被销毁，如果被销毁就需要将加载中的ab包的实际被加载次数减一。
3.当ab包资源加载完毕时，如果发现加载中的此ab包维护的实际被加载次数大于0，此时ab包的引用次数加一，同时实际被加载次数减一。
4.当界面销毁时，此界面的ab包和相关依赖的引用次数需要减一，动态加载的ab包资源也需要将引用次数减一
5.！！！需要注意的是 当A依赖于B时，  A的最后一个实例被销毁时  A的引用变为0  但是B的引用此刻不变，除非A被卸载 才能将B的引用减一
                //  A依赖于B
                //  A被加载 会先加载B
                //那么A引用为1 B引用为1
                //A被加载第二次 A引用为2 B引用为2
                //A被加载第3次 A引用为3 B引用为3
                // A被删除1次  引用为2  B引用为2
                //A被删除第二次 A引用为1 B引用为1
                //A被删除第3次 A引用为0 B引用为1
                //A被卸载时  B引用为0
                //  A依赖于B
                //  A被加载 会先加载B
                //那么A引用为1 B引用为1
                //A被加载第二次 A引用为2 B引用为2
                // A被删除1次  引用为1  B引用为1
                //A被删除第二次 A引用为0 B引用为1
                //A被卸载时  B引用为0
                //  A依赖于B
                //  A被加载 会先加载B
                //那么A引用为1 B引用为1
                // A被删除1次  A引用为0  B引用为1
                //A被卸载时  B引用为0
 */
[SelectionBase]
public class LoadingAssetBundle
{
    private string abName;
    public string GetABName()
    {
        return abName;
    }
 
    private int realLoadedTimesInLoading = 0;//在加载中 被加载的真实次数（也就是剔除那些只加载不使用的部分,例如界面动态加载图片还没加载完毕 这个界面就被销毁了）
    public int GetRealLoadedTimesInLoading()
    {
        return realLoadedTimesInLoading;
    }
 
    public void AddRealLoadedTimesInLoading()
    {
        realLoadedTimesInLoading++;
    }
 
    public void ReduceRealLoadedTimesInLoading()
    {
        realLoadedTimesInLoading--;
    }
 
    public LoadingAssetBundle(string _abName)
    {
        abName = _abName;
        AddRealLoadedTimesInLoading();
    }
}
 
[SelectionBase]
public class LoadedAssetBundle
{
    private string abName;
    private AssetBundle bundle;
    private float cacheTimeBySenconds = 10;//缓存秒数不同ab可配置
    public float curLastCacheTime = 10;//当前剩余缓存时间
    public int referenceTimes = 0;//引用次数
    public long memoryValue = 0;//ab包大小
    public int loadIndexOrder = 0;//引用顺序 越小代表越早被引用
    private bool isUnload = false;//是否被卸载
 
    public LoadedAssetBundle(string _abName, AssetBundle _bundle, long _memoryValue, int _loadIndexOrder)
    {
        isUnload = false;
        abName = _abName;
        bundle = _bundle;
        memoryValue = _memoryValue;//long size = long.Parse(unityWebRequest.GetResponseHeader("Content-Length"));
        ABManager.Instance.AddMemoryValue(_memoryValue);
        loadIndexOrder = _loadIndexOrder;
    }
 
    public AssetBundle GetAssetBundle()
    {
        return bundle;
    }
 
    public void AddRefer()//添加引用1
    {
        referenceTimes = referenceTimes + 1;
        curLastCacheTime = cacheTimeBySenconds;//重置剩余缓存1时间时间
    }
 
    public int ReduceRefer()//减少引用
    {
        if (referenceTimes > 0) {
            referenceTimes--;
        };
        return referenceTimes;
    }
 
    public void RefreshCacheLastTime(float time)
    {
        if (referenceTimes == 0)
        { 
            curLastCacheTime -= time;
            CheckCacheTimeUnload();
        }
    }
 
 
 
    private void CheckCacheTimeUnload()
    {
        if (isUnload) return;
        if (curLastCacheTime <= 0&& referenceTimes == 0) { 
            bundle.Unload(true); //卸载时机1
            isUnload = true; 
            ABManager.Instance.ReduceMemoryValue(memoryValue);
            ABManager.Instance.RemoveABRequest(abName);
            ABManager.Instance.ReduceDependciedRefer(abName);
            Debug.Log($"curLastCacheTime Unload{abName}，Count={ABManager.Instance.cachedLoadedDic.Count}");
        }
    }
    public void CheckOverMemoryUnload(int curMinReferIndexOrder)
    {
        if (isUnload) return;
        if (referenceTimes == 0 && ABManager.Instance.CheckOverMemoryMemoryReferenceValue())//&& curMinReferIndexOrder == loadIndexOrder
        {
            bundle.Unload(true);//卸载时机2
            isUnload = true;
            ABManager.Instance.ReduceMemoryValue(memoryValue);
            ABManager.Instance.RemoveABRequest(abName);
            ABManager.Instance.ReduceDependciedRefer(abName);
            Debug.Log($"Unload{abName}");
        }
    }
 
    public string GetABName()
    {
        return abName;
    }
 
    public bool IsUnLoad()
    {
        return isUnload;
    }
}
 
 
public class ABManager : MonoSingleton<ABManager>
{
 
    public Dictionary<string, LoadedAssetBundle> cachedLoadedDic = new Dictionary<string, LoadedAssetBundle>();
    private Dictionary<string, LoadingAssetBundle> cachedLoadingDic = new Dictionary<string, LoadingAssetBundle>();
    private long memoryReferenceValue= 995406;//内存基准值
    private long curMemoryValue = 0;//内存当前值
    private int curReferIndexOrder = 0;//当前索引
    private int curMinReferIndexOrder = 0;//当前被加载最早的索引
    public void AddMemoryValue(long _memoryValue)
    {
        curMemoryValue = curMemoryValue + _memoryValue;
        //print("curMemoryValue" + curMemoryValue);
    }
    public void ReduceMemoryValue(long _memoryValue)
    {
        //Debug.Log("memoryValue" + _memoryValue);
        curMemoryValue = curMemoryValue - _memoryValue;
        curMinReferIndexOrder++;
        if (curMinReferIndexOrder  > curReferIndexOrder)
        {
            curMinReferIndexOrder = curReferIndexOrder;
        }
    }
 
    public bool CheckOverMemoryMemoryReferenceValue()
    {
        return curMemoryValue > memoryReferenceValue;
    }
 
 
    private float checkSpan =  0.3f;
    public float time;
    List<string> removeList = new List<string>();
    public int CachedLoadedCount;
    private void CheckUnLoadCachedLoaded()
    {
        time += Time.fixedDeltaTime;
        if (time > checkSpan)
        {
            time = 0;
            removeList.Clear();
            foreach (var item in cachedLoadedDic)
            {
                if (!cachedLoadingDic.ContainsKey(item.Key))
                {
                    item.Value.RefreshCacheLastTime(checkSpan);
                    item.Value.CheckOverMemoryUnload(curMinReferIndexOrder);
                    if (item.Value.IsUnLoad()) removeList.Add(item.Key);
                }
            }
 
            for (int i = 0; i < removeList.Count; i++)
            {
                print($"removeList={removeList[i]}");
                cachedLoadedDic.Remove(removeList[i]);
            }
        }
        CachedLoadedCount = cachedLoadedDic.Count;
    }
 
 
    // Update is called once per frame
    void FixedUpdate()
    {
        CheckUnLoadCachedLoaded();
    }
 
    private AssetBundle mainAB = null; //主包
    private AssetBundleManifest mainManifest = null; //主包中配置文件---用以获取依赖包
    private string basePath = "http://192.168.31.208/AssetBundles/";
    private string mainABName = "AssetBundles";
 
 
    public Dictionary<string, string> AssetNameToABName = new Dictionary<string, string>();
    public async UniTask<GameObject> LoadAsset(string assetName)
    {
        string abName = assetName.ToLower() + ".ab";
        AssetBundle ab = await LoadABPackage(abName);
        //await UniTask.SwitchToMainThread();
        return ab.LoadAsset<GameObject>(assetName);
    }
 
 
    /// <summary>
    /// 加载图集里面的图片
    /// 案例
    ///   Image a = nul;;
    ///   if (a != null)
    ///        ABManager.Instance.UnloadAsset(a);
    ///    a = ABManager.Instance.LoadAtlasSprite(a);
    /// </summary>
    /// <param name="assetName"></param>
    /// <param name="textureName"></param>
    /// <returns></returns>
    public async UniTask<Sprite> LoadAtlasSprite(string assetName, string textureName)
    {
        string abName = assetName.ToLower() + ".ab";
        AssetBundle ab = await LoadABPackage(abName);
        SpriteAtlas spriteAtlas = ab.LoadAsset<SpriteAtlas>(assetName);
        return spriteAtlas.GetSprite(textureName);
    }
 
    //单个包卸载
    public void ReduceRefer(string assetName)
    {
        string abName = assetName.ToLower() + ".ab";
 
        if (cachedLoadingDic.ContainsKey(abName))
        {
            cachedLoadingDic[abName].ReduceRealLoadedTimesInLoading();
 
        }
        else
        {
            //--引用
            if (cachedLoadedDic.ContainsKey(abName))
            {
              int referValue =  cachedLoadedDic[abName].ReduceRefer();
 
                //  A依赖于B
                //  A被加载 会先加载B
                //那么A引用为1 B引用为1
                //A被加载第二次 A引用为2 B引用为2
                //A被加载第3次 A引用为3 B引用为3
                // A被删除1次  引用为2  B引用为2
                //A被删除第二次 A引用为1 B引用为1
                //A被删除第3次 A引用为0 B引用为1
                //A被卸载时  B引用为0
 
                //  A依赖于B
                //  A被加载 会先加载B
                //那么A引用为1 B引用为1
                //A被加载第二次 A引用为2 B引用为2
                // A被删除1次  引用为1  B引用为1
                //A被删除第二次 A引用为0 B引用为1
                //A被卸载时  B引用为0
 
 
                //  A依赖于B
                //  A被加载 会先加载B
                //那么A引用为1 B引用为1
                // A被删除1次  A引用为0  B引用为1
                //A被卸载时  B引用为0
 
                if (referValue > 0)
                {
                    ReduceDependciedRefer(abName);
                }
            }
        }
 
    }
 
 
    public void ReduceDependciedRefer(string abName)
    {
        string[] dependencies = mainManifest.GetAllDependencies(abName);
        for (int i = 0; i < dependencies.Length; i++)
        {
            if (cachedLoadedDic.ContainsKey(dependencies[i]))
            {
                cachedLoadedDic[dependencies[i]].ReduceRefer();
            }
        }
    }
 
 
 
 
 
 
 
    //加载AB包
    private async UniTask<AssetBundle> LoadABPackage(string abName)
    {
 
        //加载ab包，需一并加载其依赖包。
        if (mainAB == null)
        {
            //获取ab包内容
            mainAB = await DownloadABPackage(mainABName);
            //获取主包下的AssetBundleManifest资源文件（存有依赖信息）
            mainManifest = mainAB.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
        }
 
        //根据manifest获取所有依赖包的名称 固定API 保证不丢失依赖
        string[] dependencies = mainManifest.GetAllDependencies(abName);
        if (dependencies.Length > 0)
        {
            var tasks = new List<UniTask>(); // 创建一个任务列表来存储异步操作
                                             //循环加载所有依赖包
            for (int i = 0; i < dependencies.Length; i++)
            {
                //如果不在缓存则加入
                if (!cachedLoadedDic.ContainsKey(dependencies[i])) 
                    tasks.Add(LoadABPackage(dependencies[i]));
                else
                {
                    cachedLoadedDic[dependencies[i]].AddRefer(); //++引用
                }
            }
            // 使用UniTask.WhenAll等待所有任务完成
            await UniTask.WhenAll(tasks);
        }
 
        //加载目标包 -- 同理注意缓存问题
        if (cachedLoadedDic.ContainsKey(abName))
        {
            cachedLoadedDic[abName].AddRefer(); //++引用
            Debug.Log($"ContainsKey{abName}");
            return (cachedLoadedDic[abName].GetAssetBundle());
        }
        else
        {
 
            await DownloadABPackage(abName);
            Debug.Log($"DownloadABPackage{abName}");
            return (cachedLoadedDic[abName].GetAssetBundle());
        }
    }
 
    //存儲下載操作
    Dictionary<string, UnityWebRequestAsyncOperation> ABRequestOpera = new Dictionary<string, UnityWebRequestAsyncOperation>();
    public void RemoveABRequest(string abname)
    {
        string url = basePath + abname;
        ABRequestOpera[url].webRequest.Dispose();//试试多个异步创建
        ABRequestOpera.Remove(url);
    }
    async UniTask<AssetBundle> DownloadABPackage(string abname)
    {
        if (cachedLoadedDic.ContainsKey(abname))
        {
            cachedLoadedDic[abname].AddRefer();
            return cachedLoadedDic[abname].GetAssetBundle();
        }
            
        string url = basePath + abname;
        Debug.Log(url);
        if (!cachedLoadingDic.ContainsKey(abname))
        {
            cachedLoadingDic.Add(abname, new LoadingAssetBundle(abname));
        }
        else
        {
            cachedLoadingDic[abname].AddRealLoadedTimesInLoading();
        }
        if (!ABRequestOpera.ContainsKey(url))
        {
            UnityWebRequest req = UnityWebRequestAssetBundle.GetAssetBundle(url);
            UnityWebRequestAsyncOperation operation = req.SendWebRequest();
            ABRequestOpera.Add(url, operation);
        }
        await ABRequestOpera[url];
        if (!cachedLoadedDic.ContainsKey(abname))
        {
            curReferIndexOrder++;
            AssetBundle ab = DownloadHandlerAssetBundle.GetContent(ABRequestOpera[url].webRequest);
            long size = long.Parse(ABRequestOpera[url].webRequest.GetResponseHeader("Content-Length"));
            cachedLoadedDic.Add(abname, new LoadedAssetBundle(abname,ab, size, curReferIndexOrder));
 
        }
 
        if (cachedLoadingDic.ContainsKey(abname)&&cachedLoadingDic[abname].GetRealLoadedTimesInLoading() > 0)
        {
            cachedLoadedDic[abname].AddRefer();
            cachedLoadingDic[abname].ReduceRealLoadedTimesInLoading();
            if (cachedLoadingDic[abname].GetRealLoadedTimesInLoading() == 0)
            {
                cachedLoadingDic.Remove(abname);
            }
        }    
        return cachedLoadedDic[abname].GetAssetBundle();
    }
 
 
 
    //所有包卸载
    public void UnLoadAll()
    {
        AssetBundle.UnloadAllAssetBundles(false);
        //注意清空缓存
        cachedLoadedDic.Clear();
        cachedLoadingDic.Clear();
        mainAB = null;
        mainManifest = null;
    }
 
 
}

3..打包AB包代码


using UnityEngine;
using UnityEditor;
using System.IO;
using System;
using System.Collections.Generic;
 
/// <summary>
/// AB包创建
/// </summary>
public class CreateAssetBundles : MonoBehaviour
{
 
    public static string BuildAssetBundlePath = Application.dataPath + "/AssetsPach/AssetBundles";
    [MenuItem("Build/BuildAssetBundles")]
    public static void BuildAssetBundle()
    {
        SetAssetBundle();
        string dir = BuildAssetBundlePath; //相对路径
        if (!Directory.Exists(dir))   //判断路径是否存在
        {
            Directory.CreateDirectory(dir);
        }
        BuildPipeline.BuildAssetBundles(dir, BuildAssetBundleOptions.None, EditorUserBuildSettings.activeBuildTarget); //这里是第一点注意事项，BuildTarget类型选择WebGL
        AssetDatabase.Refresh();
        Debug.Log("打包完成");
    }
 
    //需要打包的资源目录
    public static string SetAssetBundlePath = Application.dataPath + "/AssetsPach/WortAsset";
    public static void SetAssetBundle()
    {
        string dir = SetAssetBundlePath; //相对路径
 
        AssetDatabase.RemoveUnusedAssetBundleNames();//移除无用的AssetBundleName
        //Debug.LogError(Application.dataPath);//上级路径 F:/TUANJIEProject/My project/Assets
        list_Files = new List<stru_FileInfo>();
        ContinueCheck(dir);
        for (int a = 0; a < list_Files.Count; a++)//
        {
            SetBundleName(list_Files[a].assetPath);
        }
        Debug.Log("生成ab包完成");
        //SetBundleName("Assets/Ship/AC_Enterprise_T01/prefab/AC_Enterprise_T01_M01_ShipMesh.prefab");
 
    }
 
 
    //******资源参数
    static List<stru_FileInfo> list_Files;//文件列表
 
    static string assetBundleName = "ab";
    static string assetBundleVariant = "";
    //int indentation;//缩进等级
    struct stru_FileInfo
    {
        public string fileName;
        public string filePath;//绝对路径
        public string assetPath;//U3D内部路径
        public Type assetType;
    }
 
 
 
 
 
    static void ContinueCheck(string path)
    {
        DirectoryInfo directory = new DirectoryInfo(path);
        FileSystemInfo[] fileSystemInfos = directory.GetFileSystemInfos();//获取文件夹下的文件信息
 
        foreach (var item in fileSystemInfos)
        {
            int idx = item.ToString().LastIndexOf(@"\");
            string name = item.ToString().Substring(idx + 1);
            if (!name.Contains(".meta"))//剔除meta文件
            {
                CheckFileOrDirectory(item, path + "/" + name);
            }
        }
    }
 
    static void CheckFileOrDirectory(FileSystemInfo fileSystemInfo, string path)
    {
        FileInfo fileInfo = fileSystemInfo as FileInfo;
        if (fileInfo != null)
        {
            stru_FileInfo t_file = new stru_FileInfo();
            t_file.fileName = fileInfo.Name;
            t_file.filePath = fileInfo.FullName;
 
            t_file.assetPath = "Assets" + fileInfo.FullName.Replace(Application.dataPath.Replace("/", "\\"), "");//用于下一步获得文件类型
            t_file.assetType = AssetDatabase.GetMainAssetTypeAtPath(t_file.assetPath);
            list_Files.Add(t_file);
        }
        else
        {
            ContinueCheck(path);
        }
    }
 
    static void SetBundleName(string path)
    {
        print(path);
        var importer = AssetImporter.GetAtPath(path);
        string[] strs = path.Split(".");
        string[] dictors = strs[0].Split('/');
        if (importer)
        {
            if (assetBundleVariant != "")
            {
                importer.assetBundleVariant = assetBundleVariant;
            }
            if (assetBundleName != "")
            {
                importer.assetBundleName = path.ToLower() + "." + assetBundleName;
            }
        }
        else
        {
            Debug.Log("importer是空的" + path);//jpg  png tga
        }
    }
 
}

4.资源如下几张美女壁纸，每个预设都是一个壁纸和关闭按钮界面挂载了代码


using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
 
public class Panel : MonoBehaviour
{
    public string asssetName;
    // Start is called before the first frame update
    void Start()
    {
        transform.GetComponentInChildren<Button>().onClick.AddListener(() => {
            //StartCoroutine(TestLoadSize();
 
            UIManager.Instance.DeletePanel(this);
        });
    }
 
    // Update is called once per frame
    void Update()
    {
        
    }
}

4.启动场景和代码


using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
 
public class UIManager :  MonoSingleton<UIManager>
{
    public Transform parent;
    // Start is called before the first frame update
    void Start()
    {
        for (int i = 0; i < transform.childCount; i++)
        {
            int index = i;
            transform.GetChild(i).GetComponent<Button>().onClick.AddListener(() => {
                //StartCoroutine(TestLoadSize();
                print(111);
                DownPanel($"Assets/Assetspach/wortasset/prefabs/Panel{index + 1}.prefab");
                //DownPanel($"Assets/Assetspach/wortasset/prefabs/Panel{index + 1}.prefab");
            });
        }
    }
 
     async void DownPanel(string asssetName)
    {
        GameObject go = await ABManager.Instance.LoadAsset(asssetName);
        GameObject.Instantiate(go, parent).GetComponent<Panel>().asssetName =asssetName;
    }
 
    // Update is called once per frame
    public  void DeletePanel(Panel panel)
    {
        ABManager.Instance.ReduceRefer(panel.asssetName);
        DestroyImmediate(panel.gameObject);
    }
}

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/546142