修复协程锁协程锁爆栈卡死bug

Author: mister91jiao

Assets/BundleMaster/BundleMasterRuntime/AssetComponentLife.cs

@@ -55,7 +55,7 @@ public static void Update()
                 }
             }
             DownLoadAction?.Invoke(nowTime);
-            
+            CoroutineLockComponent.UpDate();
         }
     }
 }

Assets/BundleMaster/CoroutineLock/CoroutineLock.cs

@@ -6,14 +6,14 @@ namespace BM
     public class CoroutineLock : IDisposable
     {
         private bool _isDispose = false;
-        internal long Key;
+        private long _key;
         private CoroutineLockQueue _coroutineLockQueue;
         private ETTask _waitTask;
 
         internal void Init(long key, CoroutineLockQueue coroutineLockQueue)
         {
             _isDispose = false;
-            this.Key = key;
+            this._key = key;
             this._coroutineLockQueue = coroutineLockQueue;
             _waitTask = ETTask.Create(true);
         }
@@ -33,12 +33,12 @@ public void Dispose()
         {
             if (_isDispose)
             {
-                //Debug.LogError("协程锁重复释放");
+                //AssetLogHelper.LogError("协程锁重复释放");
                 return;
             }
             _waitTask = null;
             _isDispose = true;
-            _coroutineLockQueue.CoroutineLockDispose(this);
+            _coroutineLockQueue.CoroutineLockDispose(_key).Coroutine();
             _coroutineLockQueue = null;
             CoroutineLockComponent.CoroutineLockQueue.Enqueue(this);
 

Assets/BundleMaster/CoroutineLock/CoroutineLockComponent.cs

@@ -1,5 +1,4 @@
 using System.Collections.Generic;
-using ET;
 
 namespace BM
 {
@@ -19,7 +18,7 @@ public static class CoroutineLockComponent
         /// 缓存池的池
         /// </summary>
         internal static readonly Queue<Queue<CoroutineLock>> CoroutineLockQueuePool = new Queue<Queue<CoroutineLock>>();
-
+        
         public static async ETTask<CoroutineLock> Wait(CoroutineLockType coroutineLockType, long key)
         {
             if (!CoroutineLockTypeToQueue.TryGetValue(coroutineLockType, out CoroutineLockQueue coroutineLockQueue))
@@ -32,6 +31,28 @@ public static async ETTask<CoroutineLock> Wait(CoroutineLockType coroutineLockTy
             await coroutineLock.Wait();
             return coroutineLock;
         }
+
+        public static void UpDate()
+        {
+            for (int i = 0; i < TaskDic.Count; i++)
+            {
+                TaskDic[i].SetResult();
+            }
+            TaskDic.Clear();
+        }
+
+        private static readonly List<ETTask> TaskDic = new List<ETTask>();
+
+        /// <summary>
+        /// 等待一个帧循环执行
+        /// </summary>
+        internal static ETTask WaitTask()
+        {
+            ETTask tcs = ETTask.Create(true);
+            TaskDic.Add(tcs);
+            return tcs;
+        }
+
     }
 }
 

Assets/BundleMaster/CoroutineLock/CoroutineLockQueue.cs

@@ -2,30 +2,57 @@
 
 namespace BM
 {
+    /// <summary>
+    /// 每个协程锁类型与其对应的队列
+    /// </summary>
     internal class CoroutineLockQueue
     {
         private CoroutineLockType _coroutineLockType;
+        /// <summary>
+        /// 每个key的以及其对应的队列
+        /// </summary>
         private readonly Dictionary<long, Queue<CoroutineLock>> _coroutineLockKeyToQueue = new Dictionary<long, Queue<CoroutineLock>>();
+
+        /// <summary>
+        /// 可以瞬间完成的锁循环的数量(与设备栈大小有关)
+        /// </summary>
+        private const int LoopCount = 200;
+        
+        /// <summary>
+        /// 递归循环次数
+        /// </summary>
+        private readonly Dictionary<long, int> _coroutineLockKeyToLoopCount = new Dictionary<long, int>();
 
         internal CoroutineLockQueue(CoroutineLockType coroutineLockType)
         {
             this._coroutineLockType = coroutineLockType;
         }
 
-        internal void CoroutineLockDispose(CoroutineLock coroutineLock)
+        internal async ETTask CoroutineLockDispose(long key)
         {
-            Queue<CoroutineLock> keyToQueue = _coroutineLockKeyToQueue[coroutineLock.Key];
+            Queue<CoroutineLock> keyToQueue = _coroutineLockKeyToQueue[key];
             if (keyToQueue.Count > 0)
             {
-                CoroutineLock nextCoroutineLock = keyToQueue.Dequeue();
-                nextCoroutineLock.Enable();
+                if (_coroutineLockKeyToLoopCount[key] > 0)
+                {
+                    _coroutineLockKeyToLoopCount[key]--;
+                    keyToQueue.Dequeue().Enable();
+                    return;
+                }
+                _coroutineLockKeyToLoopCount[key] = LoopCount;
+                await CoroutineLockComponent.WaitTask();
+                keyToQueue.Dequeue().Enable();
                 return;
             }
             keyToQueue.Clear();
             CoroutineLockComponent.CoroutineLockQueuePool.Enqueue(keyToQueue);
-            _coroutineLockKeyToQueue.Remove(coroutineLock.Key);
+            _coroutineLockKeyToQueue.Remove(key);
+            _coroutineLockKeyToLoopCount.Remove(key);
         }
 
+        /// <summary>
+        /// 获取一个锁头
+        /// </summary>
         internal CoroutineLock GetCoroutineLock(long key)
         {
             CoroutineLock coroutineLock;
@@ -49,6 +76,7 @@ internal CoroutineLock GetCoroutineLock(long key)
                 {
                     coroutineLockQueue = new Queue<CoroutineLock>();
                 }
+                _coroutineLockKeyToLoopCount.Add(key, LoopCount);
                 _coroutineLockKeyToQueue.Add(key, coroutineLockQueue);
                 coroutineLock.Enable();
             }