当前位置:   article > 正文

Unity通用框架搭建(四)—— 缓存池设计_unitask addressable抛异常

unitask addressable抛异常

前面一文基于Addressable的资源加载更新记录了资源的加载,本文将紧贴资源的加载,结合设计模式中的享元模式的理念设计对象缓存池,避免在游戏过程中频繁的进行创建和销毁的工作。

缓存池设计

基于Addressable的资源加载更新一文中有提到缓存池的结构,主要分为以下几大模块:

  • 缓存对象类:
    1、缓存对象类需要有当前正在使用的对象的缓存references使用列表,用来存储正在使用的对象
    2、使用caches,来存储在注销时候应该的销毁的对象,后期使用时直接复用,不在重新创建。
    3、清理参数Exceed,定时触发清理多余的缓存对象,保留部分,避免过多的缓存对象占用过多的内存。
    当程序需要加载某一对象,先判断是否存在缓存的对象,如果存在,直接将缓存对象出栈(caches采用堆栈结构存储),没有缓存对象才重新创建对象。当程序需要销毁对象时并不直接销毁,而是将对象放回至caches缓存池里,方便重复使用。
 private class CacheList
    {
        /// <summary>
        /// 资源地址
        /// </summary>
        public string Address;

        /// <summary>
        /// 缓存列表
        /// </summary>
        private Stack<T> caches = new Stack<T>();

        /// <summary>
        /// 正在使用的列表
        /// </summary>
        private HashSet<T> references = new HashSet<T>();

        /// <summary>
        /// 清理参数
        /// </summary>
        public float Exceed = AssetPoolManager.Exceed;

        /// <summary>
        /// 模板
        /// </summary>
        public UnityEngine.Object Prefab;

        private int maxReferenceNumber = 0;

        public bool isAddressableAssets;

        /// <summary>
        /// 总计缓存数量
        /// </summary>
        public int Count
        {
            get
            {
                return this.references.Count + this.caches.Count;
            }
        }


        /// <summary>
        /// 可以使用的缓存对象的数量
        /// </summary>
        public int CachesCount
        {
            get
            {
                return this.caches.Count;
            }
        }

        /// <summary>
        /// 添加使用项
        /// </summary>
        /// <param name="t"></param>
        public void AddReference(T t)
        {
            if (this.references.Add(t))
            {
                this.maxReferenceNumber = this.references.Count > this.maxReferenceNumber ? this.references.Count : this.maxReferenceNumber;
            }
        }

        /// <summary>
        /// 从缓存池中取出一个项使用
        /// </summary>
        /// <returns></returns>
        public T Pop()
        {
            if (this.caches.Count > 0)
            {
                T _reference = this.caches.Pop();
                this.AddReference(_reference);
                return _reference;
            }
            else
            {
                throw new System.Exception(string.Format("{0} CacheList's caches is empty but use pop", Prefab.name));
            }
        }

        /// <summary>
        /// 使用完成之后放回缓存池
        /// </summary>
        /// <param name="t"></param>
        public void Push(T t)
        {
            this.caches.Push(t);
            this.references.Remove(t);
            InitInfomation();
        }

        public void Delete(T t)
        {
            this.references.Remove(t);
            GameObject.Destroy(t.gameObject);
        }

        /// <summary>
        /// 使用计算
        /// </summary>
        internal void InitInfomation()
        {
            this.maxReferenceNumber = this.references.Count;
        }

        public void ClearCaches(Dictionary<T, CacheList> lookup)
        {
            foreach (var obj in this.caches)
            {
                lookup.Remove(obj);
                GameObject.Destroy(obj.gameObject);
            }
            foreach (var obj in this.references)
            {
                lookup.Remove(obj);
                GameObject.Destroy(obj.gameObject);
            }
            this.caches.Clear();
            this.references.Clear();
            Prefab = null;
            if (isAddressableAssets)
                AddressableManager.Instance.UnLoadAsset(Address);
        }

        /// <summary>
        /// 清理多余的缓存资源
        /// </summary>
        /// <returns></returns>
        public List<T> CleanCache()
        {
            int cleanCount = this.Count - ((int)(this.maxReferenceNumber * Exceed));
            if (cleanCount > 0)
            {
                List<T> list = new List<T>();
                for (int i = 0; i < cleanCount; i++)
                {
                    list.Add(this.caches.Pop());
                }
                return list;
            }
            return null;
        }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147

缓存池实现逻辑AddressablePool

为方便不同的资源类型复用缓存池的逻辑,这里将采用泛型来实现缓存的逻辑,将CacheList类设计为AddressablePool的嵌入类类型。AddressablePool负责判断加载逻辑是使用缓存池的对象还是重新创建新的对象。

  • Dictionary<string, CacheList> pools :资源缓存池,用来缓存不用名字的资源
  • Dictionary<T, CacheList> lookup:为方便快速的定位缓存池对象,需要在创建对象的时候加入缓存查找表,以后后期的快速定位。
  • 添加模板:
    为实现通用性,游戏开发中可能存在不需要从本来加载模板的情况,界面本身已经存在GameObject了,这是不在需要加载的过程因此将添加模板的方法独立出来
public void AddTemplate(string address, UnityEngine.Object obj, bool isAddressabel=true, float Exceed = AddressableManager.Exceed)
    {
        if (!this.pools.ContainsKey(address))
        {
            CacheList cache = new CacheList();
            cache.Address = address;
            cache.Prefab = obj;
            cache.Exceed = Exceed;
            cache.isAddressableAssets = isAddressabel;
            isLoad = false;
            this.pools.Add(address, cache);
        }
        else
        {
            Helper.LogError("速查,出现同名资源:" + address);
        }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

在界面上直接传入模板(GameObject),也能使用这个缓存池的方法(在飘提示文字的时候经常用到),如果是需要加载,则在加载完成之后也调用该方法,只需要用个标记来区分是加载的模板还是外部直接传入的模板(资源清理时,加载的模板需要调用释放接口。界面上直接传入的则不用)。

  • 使用Addressable的异步加载,如果已经启动了加载程序则缓存加载完成回调,避免重复加载导致系统抛出异常。(Addressable的底层是基于AssetBundle设计的,重复加载会抛异常
 public void LoadAsset(string address, System.Action<T> onComplete, float Exceed = AssetPoolManager.Exceed)
    {
        isLoad = true;
        CacheList cache;
        if (this.pools.TryGetValue(address, out cache))
        {
            isLoad = false;
            var obj = LoadAssetByTemplate(address);
            if (obj != null)
            {
                onComplete(obj);
            }
            else
            {
                Helper.LogWarning("加载资源失败,请检查 :" + address);
            }
        }
        else
        {
            List<System.Action<T>> callBackList;
            if (loadCallBack.TryGetValue(address, out callBackList))
            {
                callBackList.Add(onComplete);
            }
            else
            {
                callBackList = new List<System.Action<T>>();
                callBackList.Add(onComplete);
                loadCallBack.Add(address, callBackList);
                AddressableManager.Instance.LoadAsset<GameObject>(address, (objAsset) => {
                    AddTemplate(address, objAsset, true, Exceed);
                    isLoad = false;
                    var list = loadCallBack[address];
                    if (objAsset != null)
                    {
                        if(list!=null&&list.Count>0)
                        {
                            for (int i = 0; i < list.Count; i++)
                            {
                                var obj = LoadAssetByTemplate(address);
                                list[i](obj);
                            }
                        }
                    }
                    else
                    {
                        Helper.LogWarning("加载资源失败,请检查 :" + address);
                    }
                    loadCallBack.Remove(address);
                }, () => {
                    Helper.LogWarning("加载资源失败,请检查 :" + address);
                });
            }
        }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 多余缓存清理,缓存中设计了清理参数,定时器会定时触发清理函数。我们需要定时的将多余的缓存清理掉,比如(10个缓存保留3个即可)这个需要通过Exceed清理参数来控制
 private void cleanCache()
    {
        if (isLoad)
            return;
        InitInfomation();
        foreach (var info in this.pools)
        {
            List<T> temps = info.Value.CleanCache();
            if (temps != null)
            {
                foreach (var obj in temps)
                {
                    this.lookup.Remove(obj);
                    GameObject.Destroy(obj.gameObject);
                }
            }
        }
        List<string> deleteList = new List<string>();
        foreach (var info in this.pools)
        {
            if (info.Value.Count == 0)
            {
                info.Value.ClearCaches(this.lookup);
                deleteList.Add(info.Key);
            }
        }
        foreach (var info in deleteList)
        {
            pools.Remove(info);
        }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/知新_RL/article/detail/87443
推荐阅读
相关标签
  

闽ICP备14008679号