Unity通用框架搭建（四）—— 缓存池设计_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