refactor : 重构异步操作模块

Assets/YooAsset/Runtime/DownloadSystem/DefaultDownloadRequest/UnityWebRequestDownloaderBase.cs

@@ -255,12 +255,7 @@ namespace YooAsset
             if (_watchdogAborted)
                 return;
 
-#if UNITY_2020_3_OR_NEWER
+            double realtimeSinceStartup = TimeUtility.RealtimeSinceStartup;
-            double realtimeSinceStartup = UnityEngine.Time.realtimeSinceStartupAsDouble;
-#else
-            double realtimeSinceStartup = UnityEngine.Time.realtimeSinceStartup;
-#endif
-
             if (DownloadedBytes != _lastDownloadBytes)
             {
                 _lastDownloadBytes = DownloadedBytes;

Assets/YooAsset/Runtime/DownloadSystem/DefaultDownloadRequest/VirtualFileDownloader.cs

@@ -87,7 +87,7 @@ namespace YooAsset
             if (Status == EDownloadRequestStatus.None)
             {
                 Status = EDownloadRequestStatus.Running;
-                _lastUpdateTime = GetUnityEngineRealtime();
+                _lastUpdateTime = TimeUtility.RealtimeSinceStartup;
             }
         }
 
@@ -99,7 +99,7 @@ namespace YooAsset
             if (Status != EDownloadRequestStatus.Running)
                 return;
 
-            double currentTime = GetUnityEngineRealtime();
+            double currentTime = TimeUtility.RealtimeSinceStartup;
             double deltaTime = currentTime - _lastUpdateTime;
             _lastUpdateTime = currentTime;
 
@@ -137,14 +137,5 @@ namespace YooAsset
         public void Dispose()
         {
         }
-
-        private double GetUnityEngineRealtime()
-        {
-#if UNITY_2020_3_OR_NEWER
-            return UnityEngine.Time.realtimeSinceStartupAsDouble;
-#else
-            return UnityEngine.Time.realtimeSinceStartup;
-#endif
-        }
     }
 }

Assets/YooAsset/Runtime/FileSystem/BundleResult/AssetBundleResult/Operation/AssetBundleLoadAllAssetsOperation.cs

@@ -108,14 +108,7 @@ namespace YooAsset
         }
         internal override void InternalWaitForAsyncComplete()
         {
-            while (true)
+            RunBatchExecution();
-            {
-                if (ExecuteWhileDone())
-                {
-                    _steps = ESteps.Done;
-                    break;
-                }
-            }
         }
     }
 }

Assets/YooAsset/Runtime/FileSystem/BundleResult/AssetBundleResult/Operation/AssetBundleLoadAssetOperation.cs

@@ -108,14 +108,7 @@ namespace YooAsset
         }
         internal override void InternalWaitForAsyncComplete()
         {
-            while (true)
+            RunBatchExecution();
-            {
-                if (ExecuteWhileDone())
-                {
-                    _steps = ESteps.Done;
-                    break;
-                }
-            }
         }
     }
 }

Assets/YooAsset/Runtime/FileSystem/BundleResult/AssetBundleResult/Operation/AssetBundleLoadSceneOperation.cs

@@ -107,7 +107,7 @@ namespace YooAsset
         internal override void InternalWaitForAsyncComplete()
         {
             //注意：场景加载不支持异步转同步，为了支持同步加载方法需要实现该方法！
-            InternalUpdate();
+            RunOnceExecution();
         }
         public override void UnSuspendLoad()
         {

Assets/YooAsset/Runtime/FileSystem/BundleResult/AssetBundleResult/Operation/AssetBundleLoadSubAssetsOperation.cs

@@ -108,14 +108,7 @@ namespace YooAsset
         }
         internal override void InternalWaitForAsyncComplete()
         {
-            while (true)
+            RunBatchExecution();
-            {
-                if (ExecuteWhileDone())
-                {
-                    _steps = ESteps.Done;
-                    break;
-                }
-            }
         }
     }
 }

Assets/YooAsset/Runtime/FileSystem/BundleResult/VirtualBundleResult/Operation/VirtualBundleLoadAllAssetsOperation.cs

@@ -109,14 +109,7 @@ namespace YooAsset
         }
         internal override void InternalWaitForAsyncComplete()
         {
-            while (true)
+            RunBatchExecution();
-            {
-                if (ExecuteWhileDone())
-                {
-                    _steps = ESteps.Done;
-                    break;
-                }
-            }
         }
     }
 }

Assets/YooAsset/Runtime/FileSystem/BundleResult/VirtualBundleResult/Operation/VirtualBundleLoadAssetOperation.cs

@@ -88,14 +88,7 @@ namespace YooAsset
         }
         internal override void InternalWaitForAsyncComplete()
         {
-            while (true)
+            RunBatchExecution();
-            {
-                if (ExecuteWhileDone())
-                {
-                    _steps = ESteps.Done;
-                    break;
-                }
-            }
         }
     }
 }

Assets/YooAsset/Runtime/FileSystem/BundleResult/VirtualBundleResult/Operation/VirtualBundleLoadSceneOperation.cs

@@ -113,7 +113,7 @@ namespace YooAsset
         internal override void InternalWaitForAsyncComplete()
         {
             //注意：场景加载不支持异步转同步，为了支持同步加载方法需要实现该方法！
-            InternalUpdate();
+            RunOnceExecution();
         }
         public override void UnSuspendLoad()
         {

Assets/YooAsset/Runtime/FileSystem/BundleResult/VirtualBundleResult/Operation/VirtualBundleLoadSubAssetsOperation.cs

@@ -100,14 +100,7 @@ namespace YooAsset
         }
         internal override void InternalWaitForAsyncComplete()
         {
-            while (true)
+            RunBatchExecution();
-            {
-                if (ExecuteWhileDone())
-                {
-                    _steps = ESteps.Done;
-                    break;
-                }
-            }
         }
     }
 }

Assets/YooAsset/Runtime/FileSystem/DefaultBuildinFileSystem/Operation/DBFSLoadBundleOperation.cs

@@ -131,14 +131,7 @@ namespace YooAsset
         }
         internal override void InternalWaitForAsyncComplete()
         {
-            while (true)
+            RunBatchExecution();
-            {
-                if (ExecuteWhileDone())
-                {
-                    _steps = ESteps.Done;
-                    break;
-                }
-            }
         }
     }
 
@@ -204,14 +197,141 @@ namespace YooAsset
         }
         internal override void InternalWaitForAsyncComplete()
         {
-            while (true)
+            RunBatchExecution();
+        }
+    }
+
+#if TUANJIE_1_7_OR_NEWER
+    /// <summary>
+    /// 加载团结文件
+    /// </summary>
+    internal class DBFSLoadInstantBundleOperation : FSLoadBundleOperation
+    {
+        private enum ESteps
+        {
+            None,
+            LoadInstantBundle,
+            CheckResult,
+            Done,
+        }
+
+        private readonly DefaultBuildinFileSystem _fileSystem;
+        private readonly PackageBundle _bundle;
+        private AssetBundleCreateRequest _createRequest;
+        private AssetBundle _assetBundle;
+        private Stream _managedStream;
+        private ESteps _steps = ESteps.None;
+
+
+        internal DBFSLoadInstantBundleOperation(DefaultBuildinFileSystem fileSystem, PackageBundle bundle)
+        {
+            _fileSystem = fileSystem;
+            _bundle = bundle;
+        }
+        internal override void InternalStart()
+        {
+            DownloadProgress = 1f;
+            DownloadedBytes = _bundle.FileSize;
+            _steps = ESteps.LoadInstantBundle;
+        }
+        internal override void InternalUpdate()
+        {
+            if (_steps == ESteps.None || _steps == ESteps.Done)
+                return;
+
+            if (_steps == ESteps.LoadInstantBundle)
             {
-                if (ExecuteWhileDone())
+                if (_bundle.Encrypted)
+                {
+                    if (_fileSystem.DecryptionServices == null)
+                    {
+                        _steps = ESteps.Done;
+                        Status = EOperationStatus.Failed;
+                        Error = $"The {nameof(IDecryptionServices)} is null !";
+                        YooLogger.Error(Error);
+                        return;
+                    }
+                }
+
+                if (IsWaitForAsyncComplete)
+                {
+                    if (_bundle.Encrypted)
+                    {
+                        var decryptResult = _fileSystem.LoadEncryptedAssetBundle(_bundle);
+                        _assetBundle = decryptResult.Result;
+                        _managedStream = decryptResult.ManagedStream;
+                    }
+                    else
+                    {
+                        string filePath = _fileSystem.GetBuildinFileLoadPath(_bundle);
+                        _assetBundle = AssetBundle.LoadFromFile(filePath);
+                    }
+                }
+                else
+                {
+                    if (_bundle.Encrypted)
+                    {
+                        var decryptResult = _fileSystem.LoadEncryptedAssetBundleAsync(_bundle);
+                        _createRequest = decryptResult.CreateRequest;
+                        _managedStream = decryptResult.ManagedStream;
+                    }
+                    else
+                    {
+                        string filePath = _fileSystem.GetBuildinFileLoadPath(_bundle);
+                        _createRequest = AssetBundle.LoadFromFileAsync(filePath);
+                    }
+                }
+
+                _steps = ESteps.CheckResult;
+            }
+
+            if (_steps == ESteps.CheckResult)
+            {
+                if (_createRequest != null)
+                {
+                    if (IsWaitForAsyncComplete)
+                    {
+                        // 强制挂起主线程（注意：该操作会很耗时）
+                        YooLogger.Warning("Suspend the main thread to load unity bundle.");
+                        _assetBundle = _createRequest.assetBundle;
+                    }
+                    else
+                    {
+                        if (_createRequest.isDone == false)
+                            return;
+                        _assetBundle = _createRequest.assetBundle;
+                    }
+                }
+
+                if (_assetBundle == null)
+                {
+                    if (_bundle.Encrypted)
+                    {
+                        _steps = ESteps.Done;
+                        Status = EOperationStatus.Failed;
+                        Error = $"Failed to load encrypted buildin asset bundle file : {_bundle.BundleName}";
+                        YooLogger.Error(Error);
+                    }
+                    else
+                    {
+                        _steps = ESteps.Done;
+                        Status = EOperationStatus.Failed;
+                        Error = $"Failed to load buildin asset bundle file : {_bundle.BundleName}";
+                        YooLogger.Error(Error);
+                    }
+                }
+                else
                 {
                     _steps = ESteps.Done;
-                    break;
+                    Result = new AssetBundleResult(_fileSystem, _bundle, _assetBundle, _managedStream);
+                    Status = EOperationStatus.Succeed;
                 }
             }
         }
+        internal override void InternalWaitForAsyncComplete()
+        {
+            RunBatchExecution();
+        }
     }
+#endif
 }

Assets/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/DCFSLoadBundleOperation.cs

@@ -262,14 +262,7 @@ namespace YooAsset
         }
         internal override void InternalWaitForAsyncComplete()
         {
-            while (true)
+            RunBatchExecution();
-            {
-                if (ExecuteWhileDone())
-                {
-                    _steps = ESteps.Done;
-                    break;
-                }
-            }
         }
     }
 
@@ -419,14 +412,7 @@ namespace YooAsset
         }
         internal override void InternalWaitForAsyncComplete()
         {
-            while (true)
+            RunBatchExecution();
-            {
-                if (ExecuteWhileDone())
-                {
-                    _steps = ESteps.Done;
-                    break;
-                }
-            }
         }
     }
 }

Assets/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/DownloadPackageBundleOperation.cs

@@ -124,14 +124,7 @@ namespace YooAsset
         }
         internal override void InternalWaitForAsyncComplete()
         {
-            while (true)
+            RunBatchExecution();
-            {
-                if (ExecuteWhileDone())
-                {
-                    _steps = ESteps.Done;
-                    break;
-                }
-            }
         }
         internal override void InternalAbort()
         {

Assets/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/Scheduler/DownloadAndCacheLocalFileOperation.cs

@@ -98,6 +98,10 @@ namespace YooAsset
             // 检测下载结果
             if (_steps == ESteps.CheckRequest)
             {
+                //TODO 更新下载后台，防止无限挂起
+                if (IsWaitForAsyncComplete)
+                    _fileSystem.DownloadBackend.Update();
+
                 DownloadProgress = _request.DownloadProgress;
                 DownloadedBytes = _request.DownloadedBytes;
                 Progress = DownloadProgress;
@@ -177,23 +181,12 @@ namespace YooAsset
         internal override void InternalAbort()
         {
             if (_request != null)
-                _request.AbortRequest();
+                _request.Dispose();
         }
         internal override void InternalWaitForAsyncComplete()
         {
-            while (true)
+            //TODO 等待导入或解压本地文件完毕，该操作会挂起主线程！
-            {
+            RunUntilCompletion();
-                //TODO 更新下载后台，防止无限挂起
-                _fileSystem.DownloadBackend.Update();
-
-                //TODO 等待导入或解压本地文件完毕，该操作会挂起主线程！
-                InternalUpdate();
-                if (IsDone)
-                    break;
-
-                //TODO 短暂休眠避免完全卡死
-                System.Threading.Thread.Sleep(1);
-            }
         }
     }
 }

Assets/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/Scheduler/DownloadAndCacheRemoteFileOperation.cs

@@ -144,7 +144,7 @@ namespace YooAsset
         internal override void InternalAbort()
         {
             if (_request != null)
-                _request.AbortRequest();
+                _request.Dispose();
         }
         internal override void InternalWaitForAsyncComplete()
         {

Assets/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/Scheduler/DownloadSchedulerOperation.cs

@@ -119,23 +119,16 @@ namespace YooAsset
         }
 
         /// <summary>
-        /// 中止所有下载任务
+        /// 释放下载资源
-        /// </summary>
-        public void AbortAll()
-        {
-            foreach (var valuePair in _downloaders)
-            {
-                valuePair.Value.AbortOperation();
-            }
-            _downloaders.Clear();
-        }
-
-        /// <summary>
-        /// 释放资源
         /// </summary>
         public void Dispose()
         {
-            AbortAll();
+            foreach (var valuePair in _downloaders)
+            {
+                var operation = valuePair.Value;
+                operation.AbortOperation();
+            }
+            _downloaders.Clear();
         }
 
         /// <summary>

Assets/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/SearchCacheFilesOperation.cs

@@ -17,7 +17,7 @@ namespace YooAsset
 
         private readonly DefaultCacheFileSystem _fileSystem;
         private IEnumerator<string> _filesEnumerator = null;
-        private float _verifyStartTime;
+        private double _verifyStartTime;
         private ESteps _steps = ESteps.None;
 
         /// <summary>
@@ -33,7 +33,7 @@ namespace YooAsset
         internal override void InternalStart()
         {
             _steps = ESteps.Prepare;
-            _verifyStartTime = UnityEngine.Time.realtimeSinceStartup;
+            _verifyStartTime = TimeUtility.RealtimeSinceStartup;
         }
         internal override void InternalUpdate()
         {
@@ -58,7 +58,7 @@ namespace YooAsset
 
                 _steps = ESteps.Done;
                 Status = EOperationStatus.Succeed;
-                float costTime = UnityEngine.Time.realtimeSinceStartup - _verifyStartTime;
+                double costTime = TimeUtility.RealtimeSinceStartup - _verifyStartTime;
                 YooLogger.Log($"Search cache files elapsed time {costTime:f1} seconds");
             }
         }

Assets/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/VerifyCacheFilesOperation.cs

@@ -25,7 +25,7 @@ namespace YooAsset
         private List<VerifyFileElement> _verifyingList;
         private int _verifyMaxNum;
         private int _verifyTotalCount;
-        private float _verifyStartTime;
+        private double _verifyStartTime;
         private int _succeedCount;
         private int _failedCount;
         private ESteps _steps = ESteps.None;
@@ -40,7 +40,7 @@ namespace YooAsset
         internal override void InternalStart()
         {
             _steps = ESteps.InitVerify;
-            _verifyStartTime = UnityEngine.Time.realtimeSinceStartup;
+            _verifyStartTime = TimeUtility.RealtimeSinceStartup;
         }
         internal override void InternalUpdate()
         {
@@ -84,7 +84,7 @@ namespace YooAsset
                 {
                     _steps = ESteps.Done;
                     Status = EOperationStatus.Succeed;
-                    float costTime = UnityEngine.Time.realtimeSinceStartup - _verifyStartTime;
+                    double costTime = TimeUtility.RealtimeSinceStartup - _verifyStartTime;
                     YooLogger.Log($"Verify cache files elapsed time {costTime:f1} seconds");
                 }
 

Assets/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/VerifyTempFileOperation.cs

@@ -69,16 +69,8 @@ namespace YooAsset
         }
         internal override void InternalWaitForAsyncComplete()
         {
-            while (true)
+            //TODO 等待子线程验证文件完毕，该操作会挂起主线程！
-            {
+            RunUntilCompletion();
-                //TODO 等待子线程验证文件完毕，该操作会挂起主线程！
-                InternalUpdate();
-                if (IsDone)
-                    break;
-
-                //TODO 短暂休眠避免完全卡死
-                System.Threading.Thread.Sleep(1);
-            }
         }
 
         private void VerifyInThread(object obj)

Assets/YooAsset/Runtime/FileSystem/DefaultEditorFileSystem/Operation/DEFSLoadBundleOperation.cs

@@ -142,14 +142,7 @@ namespace YooAsset
         }
         internal override void InternalWaitForAsyncComplete()
         {
-            while (true)
+            RunBatchExecution();
-            {
-                if (ExecuteWhileDone())
-                {
-                    _steps = ESteps.Done;
-                    break;
-                }
-            }
         }
     }
 }

Assets/YooAsset/Runtime/FileSystem/DefaultWebRemoteFileSystem/Operation/DWRFSLoadBundleOperation.cs

@@ -91,7 +91,7 @@ namespace YooAsset
                 _steps = ESteps.Done;
                 Status = EOperationStatus.Failed;
                 Error = "WebGL platform not support sync load method !";
-                UnityEngine.Debug.LogError(Error);
+                YooLogger.Error(Error);
             }
         }
     }

Assets/YooAsset/Runtime/FileSystem/DefaultWebServerFileSystem/Operation/DWSFSLoadBundleOperation.cs

@@ -91,7 +91,7 @@ namespace YooAsset
                 _steps = ESteps.Done;
                 Status = EOperationStatus.Failed;
                 Error = "WebGL platform not support sync load method !";
-                UnityEngine.Debug.LogError(Error);
+                YooLogger.Error(Error);
             }
         }
     }

Assets/YooAsset/Runtime/OperationSystem/AsyncOperationBase.cs

@@ -10,7 +10,7 @@ namespace YooAsset
     {
         private List<AsyncOperationBase> _childs;
         private Action<AsyncOperationBase> _callback;
-        private int _whileFrame = 1000;
+        private uint _priority = 0;
 
         /// <summary>
         /// 等待异步执行完成
@@ -35,10 +35,28 @@ namespace YooAsset
             }
         }
 
+        /// <summary>
+        /// 标记脏（用于调度器检测并重排）
+        /// </summary>
+        internal bool IsDirty { set; get; } = false;
+
         /// <summary>
         /// 任务优先级
         /// </summary>
-        public uint Priority { set; get; } = 0;
+        public uint Priority
+        {
+            set
+            {
+                if (_priority == value)
+                    return;
+                _priority = value;
+                IsDirty = true;
+            }
+            get
+            {
+                return _priority;
+            }
+        }
 
         /// <summary>
         /// 任务状态
@@ -122,7 +140,7 @@ namespace YooAsset
         }
         internal virtual void InternalWaitForAsyncComplete()
         {
-            throw new System.NotImplementedException(this.GetType().Name);
+            throw new YooInternalException($"InternalWaitForAsyncComplete() not implemented : {this.GetType().Name}");
         }
         internal virtual string InternalGetDesc()
         {
@@ -137,9 +155,19 @@ namespace YooAsset
             if (_childs == null)
                 _childs = new List<AsyncOperationBase>(10);
 
-#if UNITY_EDITOR
+#if UNITY_EDITOR || DEBUG
+            if (child == null)
+                throw new YooInternalException("The child node is null !");
+
+            if (ReferenceEquals(child, this))
+                throw new YooInternalException("The child node cannot be itself !");
+
             if (_childs.Contains(child))
                 throw new YooInternalException($"The child node {child.GetType().Name} already exists !");
+
+            // 禁止形成环依赖
+            if (WouldCreateCycle(child))
+                throw new YooInternalException($"AddChildOperation would create a cycle : {this.GetType().Name} -> {child.GetType().Name}");
 #endif
 
             _childs.Add(child);
@@ -153,7 +181,10 @@ namespace YooAsset
             if (_childs == null)
                 return;
 
-#if UNITY_EDITOR
+#if UNITY_EDITOR || DEBUG
+            if (child == null)
+                throw new YooInternalException("The child node is null !");
+
             if (_childs.Contains(child) == false)
                 throw new YooInternalException($"The child node {child.GetType().Name} not exists !");
 #endif
@@ -182,7 +213,16 @@ namespace YooAsset
                 DebugBeginRecording();
 
                 // 开始任务
-                InternalStart();
+                try
+                {
+                    InternalStart();
+                }
+                catch (Exception ex)
+                {
+                    Status = EOperationStatus.Failed;
+                    Error = ex.ToString();
+                    YooLogger.Error($"Exception in {this.GetType().Name}.InternalStart : {ex}");
+                }
             }
         }
 
@@ -197,7 +237,18 @@ namespace YooAsset
                 DebugUpdateRecording();
 
                 // 更新任务
-                InternalUpdate();
+                // 注意：兜底隔离机制
+                // 说明：检测的异常源包含：I/O（解压/读写权限/磁盘满），平台差异等
+                try
+                {
+                    InternalUpdate();
+                }
+                catch (Exception ex)
+                {
+                    Status = EOperationStatus.Failed;
+                    Error = ex.ToString();
+                    YooLogger.Error($"Exception in {this.GetType().Name}.InternalUpdate : {ex}");
+                }
             }
 
             if (IsDone && IsFinish == false)
@@ -226,12 +277,15 @@ namespace YooAsset
                 Error = "user abort";
                 YooLogger.Warning($"Async operation {this.GetType().Name} has been aborted !");
             }
+
+            //注意：强制收尾，确保Task能完成
+            FinishOperation();
         }
 
         /// <summary>
         /// 强制结束异步任务
         /// </summary>
-        internal void FinishOperation()
+        private void FinishOperation()
         {
             if (IsFinish == false)
             {
@@ -243,6 +297,7 @@ namespace YooAsset
 
                 try
                 {
+                    //TODO 单个回调异常会阻断后续回调
                     _callback?.Invoke(this);
                 }
                 catch (Exception ex)
@@ -259,25 +314,58 @@ namespace YooAsset
         }
 
         /// <summary>
-        /// 执行While循环
+        /// 执行一次更新逻辑
         /// </summary>
-        protected bool ExecuteWhileDone()
+        protected void RunOnceExecution()
         {
-            if (IsDone == false)
+            if (IsDone)
+                return;
+
+            UpdateOperation();
+        }
+
+        /// <summary>
+        /// 批量执行一定次数的更新逻辑
+        /// </summary>
+        /// <param name="count">次数</param>
+        protected void RunBatchExecution(int count = 1000)
+        {
+            if (IsDone)
+                return;
+
+            int runCount = count;
+            while (true)
             {
                 // 执行更新逻辑
-                InternalUpdate();
+                UpdateOperation();
+                if (IsDone)
+                    break;
 
                 // 当执行次数用完时
-                _whileFrame--;
+                runCount--;
-                if (_whileFrame <= 0)
+                if (runCount <= 0)
-                {
+                    break;
-                    Status = EOperationStatus.Failed;
+            }
-                    Error = $"Operation {this.GetType().Name} failed to wait for async complete !";
+        }
-                    YooLogger.Error(Error);
+
-                }
+        /// <summary>
+        /// 无限次数的执行更新逻辑，直到任务完成
+        /// </summary>
+        /// <param name="sleepMS">休眠时长</param>
+        protected void RunUntilCompletion(int sleepMS = 1)
+        {
+            if (IsDone)
+                return;
+
+            while (true)
+            {
+                UpdateOperation();
+                if (IsDone)
+                    break;
+
+                // 注意： 短暂休眠避免完全占用CPU资源
+                System.Threading.Thread.Sleep(sleepMS);
             }
-            return IsDone;
         }
 
         /// <summary>
@@ -285,11 +373,7 @@ namespace YooAsset
         /// </summary>
         public void WaitForAsyncComplete()
         {
-            if (IsDone)
-                return;
-
             //TODO 防止异步操作被挂起陷入无限死循环！
-            // 例如：文件解压任务或者文件导入任务！
             if (Status == EOperationStatus.None)
             {
                 StartOperation();
@@ -298,12 +382,19 @@ namespace YooAsset
             if (IsWaitForAsyncComplete == false)
             {
                 IsWaitForAsyncComplete = true;
-                InternalWaitForAsyncComplete();
 
-#if UNITY_EDITOR
                 if (IsDone == false)
-                    throw new YooInternalException($"WaitForAsyncComplete() must complete operation: {this.GetType().Name}");
+                    InternalWaitForAsyncComplete();
-#endif
+
+                if (IsDone == false)
+                {
+                    Status = EOperationStatus.Failed;
+                    Error = $"Operation {this.GetType().Name} failed to wait for async complete !";
+                    YooLogger.Error(Error);
+                }
+
+                //注意：强制收尾，确保Task能完成
+                FinishOperation();
             }
         }
 
@@ -311,7 +402,7 @@ namespace YooAsset
         /// <summary>
         /// 开始的时间
         /// </summary>
-        public string BeginTime = string.Empty;
+        public string BeginTime { protected set; get; }
 
         /// <summary>
         /// 处理耗时（单位：毫秒）
@@ -326,7 +417,7 @@ namespace YooAsset
         {
             if (_watch == null)
             {
-                BeginTime = SpawnTimeToString(UnityEngine.Time.realtimeSinceStartup);
+                BeginTime = SpawnTimeToString(TimeUtility.RealtimeSinceStartup);
                 _watch = Stopwatch.StartNew();
             }
         }
@@ -350,13 +441,46 @@ namespace YooAsset
             }
         }
 
-        private string SpawnTimeToString(float spawnTime)
+        private string SpawnTimeToString(double spawnTime)
         {
-            float h = UnityEngine.Mathf.FloorToInt(spawnTime / 3600f);
+            double h = System.Math.Floor(spawnTime / 3600);
-            float m = UnityEngine.Mathf.FloorToInt(spawnTime / 60f - h * 60f);
+            double m = System.Math.Floor(spawnTime / 60 - h * 60);
-            float s = UnityEngine.Mathf.FloorToInt(spawnTime - m * 60f - h * 3600f);
+            double s = System.Math.Floor(spawnTime - m * 60 - h * 3600);
             return h.ToString("00") + ":" + m.ToString("00") + ":" + s.ToString("00");
         }
+        private bool WouldCreateCycle(AsyncOperationBase child)
+        {
+            const int maxVisited = 4096;
+            var stack = new Stack<AsyncOperationBase>();
+            var visited = new HashSet<AsyncOperationBase>();
+            stack.Push(child);
+
+            while (stack.Count > 0)
+            {
+                var node = stack.Pop();
+                if (node == null)
+                    continue;
+
+                if (visited.Add(node) == false)
+                    continue;
+
+                if (visited.Count > maxVisited)
+                    throw new YooInternalException("Child operation graph is too large, cycle check aborted !");
+
+                if (ReferenceEquals(node, this))
+                    return true;
+
+                if (node._childs == null)
+                    continue;
+
+                for (int i = 0; i < node._childs.Count; i++)
+                {
+                    stack.Push(node._childs[i]);
+                }
+            }
+
+            return false;
+        }
 
         internal DebugOperationInfo GetDebugOperationInfo()
         {

Assets/YooAsset/Runtime/OperationSystem/OperationScheduler.cs

@@ -10,6 +10,7 @@ namespace YooAsset
     {
         private readonly List<AsyncOperationBase> _operations = new List<AsyncOperationBase>(100);
         private readonly List<AsyncOperationBase> _newList = new List<AsyncOperationBase>(100);
+        private uint _priority = 0;
 
         /// <summary>
         /// 所属包裹名称
@@ -19,7 +20,23 @@ namespace YooAsset
         /// <summary>
         /// 调度器优先级（值越大越优先）
         /// </summary>
-        public int Priority { private set; get; }
+        public uint Priority
+        {
+            get { return _priority; }
+            set
+            {
+                if (_priority != value)
+                {
+                    _priority = value;
+                    IsDirty = true;
+                }
+            }
+        }
+
+        /// <summary>
+        /// 优先级是否已变更（需要重新排序）
+        /// </summary>
+        public bool IsDirty { set; get; } = false;
 
         /// <summary>
         /// 创建顺序（用于同优先级稳定排序）
@@ -27,10 +44,9 @@ namespace YooAsset
         public int CreateIndex { private set; get; }
 
 
-        public OperationScheduler(string packageName, int priority, int createIndex)
+        public OperationScheduler(string packageName, int createIndex)
         {
             PackageName = packageName;
-            Priority = priority;
             CreateIndex = createIndex;
         }
 
@@ -41,9 +57,6 @@ namespace YooAsset
         {
             _newList.Add(operation);
             operation.StartOperation();
-
-            // 通知开始回调
-            OperationSystem.InvokeStartCallback(PackageName, operation);
         }
 
         /// <summary>
@@ -58,31 +71,29 @@ namespace YooAsset
                 if (operation.IsFinish)
                 {
                     _operations.RemoveAt(i);
-
-                    // 通知完成回调
-                    OperationSystem.InvokeFinishCallback(PackageName, operation);
                 }
             }
 
             // 添加新增的异步操作
             if (_newList.Count > 0)
             {
-                bool sorting = false;
-                foreach (var operation in _newList)
-                {
-                    if (operation.Priority > 0)
-                    {
-                        sorting = true;
-                        break;
-                    }
-                }
-
                 _operations.AddRange(_newList);
                 _newList.Clear();
+            }
 
-                // 重新排序优先级
+            // 检测是否需要执行排序
-                if (sorting)
+            bool isDirty = false;
-                    _operations.Sort();
+            foreach (var operation in _operations)
+            {
+                if (operation.IsDirty)
+                {
+                    operation.IsDirty = false;
+                    isDirty = true;
+                }
+            }
+            if (isDirty)
+            {
+                _operations.Sort();
             }
 
             // 更新进行中的异步操作
@@ -109,7 +120,6 @@ namespace YooAsset
             foreach (var operation in _newList)
             {
                 operation.AbortOperation();
-                operation.FinishOperation(); //注意：强制收尾，确保Task能完成
             }
             _newList.Clear();
 
@@ -117,7 +127,6 @@ namespace YooAsset
             foreach (var operation in _operations)
             {
                 operation.AbortOperation();
-                operation.FinishOperation(); //注意：强制收尾，确保Task能完成
             }
             _operations.Clear();
         }

Assets/YooAsset/Runtime/OperationSystem/OperationSystem.cs

@@ -5,7 +5,7 @@ using System.Diagnostics;
 
 namespace YooAsset
 {
-    internal class OperationSystem
+    internal static class OperationSystem
     {
 #if UNITY_EDITOR
         [UnityEngine.RuntimeInitializeOnLoadMethod(UnityEngine.RuntimeInitializeLoadType.SubsystemRegistration)]
@@ -16,16 +16,13 @@ namespace YooAsset
 #endif
 
         // 全局调度器名称
-        public const string GLOBAL_SCHEDULER_NAME = "";
+        public const string GLOBAL_SCHEDULER_NAME = "YOOASSET_GLOBAL_SCHEDULER";
 
         private static readonly Dictionary<string, OperationScheduler> _schedulerDic = new Dictionary<string, OperationScheduler>(100);
         private static readonly List<OperationScheduler> _schedulerList = new List<OperationScheduler>(100);
-        private static bool _schedulerListDirty = false;
+        private static bool _isInitialize = false;
         private static int _createIndex = 0;
 
-        private static Action<string, AsyncOperationBase> _startCallback = null;
-        private static Action<string, AsyncOperationBase> _finishCallback = null;
-
         // 计时器相关
         private static Stopwatch _watch;
         private static long _frameTime;
@@ -59,10 +56,14 @@ namespace YooAsset
         /// </summary>
         public static void Initialize()
         {
-            _watch = Stopwatch.StartNew();
+            if (_isInitialize == false)
+            {
+                _isInitialize = true;
+                _watch = Stopwatch.StartNew();
 
-            // 创建全局调度器
+                // 创建全局调度器
-            CreatePackageScheduler(GLOBAL_SCHEDULER_NAME, 0);
+                CreatePackageScheduler(GLOBAL_SCHEDULER_NAME, uint.MaxValue);
+            }
         }
 
         /// <summary>
@@ -70,10 +71,21 @@ namespace YooAsset
         /// </summary>
         public static void Update()
         {
-            // 重新排序调度器
+            if (_isInitialize == false)
-            if (_schedulerListDirty)
+                return;
+
+            // 检测是否需要执行排序
+            bool isDirty = false;
+            foreach (var scheduler in _schedulerList)
+            {
+                if (scheduler.IsDirty)
+                {
+                    scheduler.IsDirty = false;
+                    isDirty = true;
+                }
+            }
+            if (isDirty)
             {
-                _schedulerListDirty = false;
                 _schedulerList.Sort();
             }
 
@@ -95,6 +107,9 @@ namespace YooAsset
         /// </summary>
         public static void DestroyAll()
         {
+            _isInitialize = false;
+            YooLogger.Log("Operation system destroy all !");
+
             // 清空所有调度器
             foreach (var scheduler in _schedulerList)
             {
@@ -102,11 +117,8 @@ namespace YooAsset
             }
             _schedulerDic.Clear();
             _schedulerList.Clear();
-            _schedulerListDirty = false;
             _createIndex = 0;
 
-            _startCallback = null;
-            _finishCallback = null;
             _watch = null;
             _frameTime = 0;
             MaxTimeSlice = long.MaxValue;
@@ -115,24 +127,29 @@ namespace YooAsset
         /// <summary>
         /// 创建包裹调度器
         /// </summary>
-        internal static void CreatePackageScheduler(string packageName, int priority)
+        public static OperationScheduler CreatePackageScheduler(string packageName, uint priority)
         {
+            DebugCheckInitialize(packageName);
+
             if (_schedulerDic.ContainsKey(packageName))
             {
                 throw new YooInternalException($"Package scheduler already exists: {packageName}");
             }
 
-            var scheduler = new OperationScheduler(packageName, priority, _createIndex++);
+            var scheduler = new OperationScheduler(packageName, _createIndex++);
             _schedulerDic.Add(packageName, scheduler);
             _schedulerList.Add(scheduler);
-            _schedulerListDirty = true;
+            scheduler.Priority = priority;
+            return scheduler;
         }
 
         /// <summary>
         /// 销毁包裹调度器
         /// </summary>
-        internal static void DestroyPackageScheduler(string packageName)
+        public static void DestroyPackageScheduler(string packageName)
         {
+            DebugCheckInitialize(packageName);
+
             // 不允许销毁默认调度器
             if (packageName == GLOBAL_SCHEDULER_NAME)
             {
@@ -152,6 +169,8 @@ namespace YooAsset
         /// </summary>
         public static void ClearPackageOperation(string packageName)
         {
+            DebugCheckInitialize(packageName);
+
             var scheduler = GetScheduler(packageName);
             scheduler.ClearAll();
         }
@@ -161,40 +180,32 @@ namespace YooAsset
         /// </summary>
         public static void StartOperation(string packageName, AsyncOperationBase operation)
         {
+            DebugCheckInitialize(packageName);
+
             var scheduler = GetScheduler(packageName);
             scheduler.StartOperation(operation);
         }
 
         /// <summary>
-        /// 监听任务开始
+        /// 设置调度器优先级
         /// </summary>
-        public static void RegisterStartCallback(Action<string, AsyncOperationBase> callback)
+        public static void SetSchedulerPriority(string packageName, uint priority)
         {
-            _startCallback = callback;
+            DebugCheckInitialize(packageName);
+
+            var scheduler = GetScheduler(packageName);
+            scheduler.Priority = priority;
         }
 
         /// <summary>
-        /// 监听任务结束
+        /// 获取调度器优先级
         /// </summary>
-        public static void RegisterFinishCallback(Action<string, AsyncOperationBase> callback)
+        public static uint GetSchedulerPriority(string packageName)
         {
-            _finishCallback = callback;
+            DebugCheckInitialize(packageName);
-        }
 
-        /// <summary>
+            var scheduler = GetScheduler(packageName);
-        /// 触发任务开始回调
+            return scheduler.Priority;
-        /// </summary>
-        internal static void InvokeStartCallback(string packageName, AsyncOperationBase operation)
-        {
-            _startCallback?.Invoke(packageName, operation);
-        }
-
-        /// <summary>
-        /// 触发任务完成回调
-        /// </summary>
-        internal static void InvokeFinishCallback(string packageName, AsyncOperationBase operation)
-        {
-            _finishCallback?.Invoke(packageName, operation);
         }
 
         /// <summary>
@@ -202,32 +213,34 @@ namespace YooAsset
         /// </summary>
         private static OperationScheduler GetScheduler(string packageName)
         {
-            // 空包名路由到默认调度器
-            if (string.IsNullOrEmpty(packageName))
-                packageName = GLOBAL_SCHEDULER_NAME;
-
             if (_schedulerDic.TryGetValue(packageName, out var scheduler))
             {
                 return scheduler;
             }
 
             // 严格模式：非默认包裹必须先创建调度器
-            throw new YooInternalException($"Package scheduler not found: {packageName}. Please call YooAssets.CreatePackage() first!");
+            throw new YooInternalException($"Operation scheduler not found: {packageName}.");
         }
 
         #region 调试信息
         internal static List<DebugOperationInfo> GetDebugOperationInfos(string packageName)
         {
-            // 空包名路由到默认调度器
+            DebugCheckInitialize(packageName);
-            if (string.IsNullOrEmpty(packageName))
-                packageName = GLOBAL_SCHEDULER_NAME;
 
-            if (_schedulerDic.TryGetValue(packageName, out var scheduler))
+            var scheduler = GetScheduler(packageName);
-            {
+            return scheduler.GetDebugOperationInfos();
-                return scheduler.GetDebugOperationInfos();
+        }
-            }
+        #endregion
 
-            return new List<DebugOperationInfo>();
+        #region 调试方法
+        [Conditional("DEBUG")]
+        private static void DebugCheckInitialize(string packageName)
+        {
+            if (string.IsNullOrWhiteSpace(packageName))
+                throw new YooInternalException("Package name is null or empty.");
+
+            if (_isInitialize == false)
+                throw new YooInternalException($"{nameof(OperationSystem)} not initialized !");
         }
         #endregion
     }

Assets/YooAsset/Runtime/OperationSystem/README.md

@@ -56,8 +56,8 @@ OperationSystem 是 YooAsset 资源管理系统的**异步操作调度核心**
 ### 核心组件
 
 - **OperationSystem**: 静态调度器，管理所有操作的执行
+- **OperationScheduler**: 包裹级调度器，维护操作队列并负责更新调度
 - **AsyncOperationBase**: 异步操作基类，定义生命周期和状态
-- **GameAsyncOperation**: 游戏层操作基类，提供更友好的 API
 - **EOperationStatus**: 操作状态枚举
 
 ---
@@ -68,8 +68,8 @@ OperationSystem 是 YooAsset 资源管理系统的**异步操作调度核心**
 OperationSystem/
 ├── EOperationStatus.cs        # 操作状态枚举
 ├── AsyncOperationBase.cs      # 异步操作基类
+├── OperationScheduler.cs      # 包裹级调度器
 ├── OperationSystem.cs         # 异步操作调度器
-└── GameAsyncOperation.cs      # 游戏层操作基类
 ```
 
 ---
@@ -113,12 +113,21 @@ None ─────────────────► Processing ───
 | `Status` | `EOperationStatus` | 当前状态 |
 | `Error` | `string` | 错误信息（失败时） |
 | `Progress` | `float` | 处理进度（0-1） |
-| `PackageName` | `string` | 所属包裹名称 |
 | `IsDone` | `bool` | 是否已完成（Succeed 或 Failed） |
 | `Task` | `Task` | 用于 async/await |
 | `BeginTime` | `string` | 开始时间（调试用） |
 | `ProcessTime` | `long` | 处理耗时毫秒（调试用） |
 
+> 说明：`AsyncOperationBase` 本身不保存包裹名称；包裹名称由 `OperationSystem.StartOperation(packageName, operation)` 传入，并由 `OperationScheduler` 维护。
+
+#### 内部协作：时间切片（`IsBusy`）
+
+为配合 `OperationSystem.MaxTimeSlice` 的时间切片预算，`AsyncOperationBase` 提供了内部属性 `IsBusy`（`internal`）用于任务在 `InternalUpdate()` 内主动让出本帧预算。
+
+- 推荐用法：在 `InternalUpdate()` 内部（或内部子步骤）在执行重逻辑前判断 `IsBusy`，若繁忙则 `return`，把工作拆到下一帧继续执行。
+- 同步等待特殊处理：当调用了 `WaitForAsyncComplete()` 进入同步等待阶段时，`IsBusy` 会强制返回 `false`，避免因时间切片判断导致同步等待无法推进。
+- 注意：`WaitForAsyncComplete()` 会阻塞主线程，应谨慎使用；同步等待阶段不受时间切片保护，可能带来卡顿。
+
 #### 公共事件
 
 ```csharp
@@ -150,14 +159,16 @@ public void WaitForAsyncComplete();
 #### 子任务管理
 
 ```csharp
-// 子任务列表
+// 添加/移除子任务（内部使用）
-internal readonly List<AsyncOperationBase> Childs;
-
-// 添加/移除子任务
 internal void AddChildOperation(AsyncOperationBase child);
 internal void RemoveChildOperation(AsyncOperationBase child);
 ```
 
+**调用约束（重要）：**
+- 仅允许在 Unity 主线程调用（与 `OperationSystem.Update()` 的调度线程一致）。
+- 不要在 `InternalUpdate()` 正在遍历/处理中途频繁增删子任务；推荐在任务启动阶段完成子任务挂接，或在确保无并发修改风险的安全点调整。
+- `AbortOperation()` 会递归中止子任务，子任务的生命周期由父任务统一管理；避免在 `Completed` 回调里再去修改子任务关系，防止时序混乱。
+
 ---
 
 ### OperationSystem（调度器）
@@ -206,61 +217,36 @@ public static void ClearPackageOperation(string packageName);
 /// 启动异步操作
 /// </summary>
 public static void StartOperation(string packageName, AsyncOperationBase operation);
+
+/// <summary>
+/// 设置调度器优先级
+/// </summary>
+public static void SetSchedulerPriority(string packageName, uint priority);
+
+/// <summary>
+/// 获取调度器优先级
+/// </summary>
+public static uint GetSchedulerPriority(string packageName);
 ```
 
+#### 包裹调度说明
+
+- `packageName` 不允许为空（`null` / `""`），否则会抛出异常。
+- 若需要使用全局调度器，请传入 `OperationSystem.GLOBAL_SCHEDULER_NAME`（`Initialize()` 时自动创建）。
+- `packageName` 为非全局调度器名称时，必须先通过 `YooAssets.CreatePackage(packageName)` 创建包裹（内部会注册对应 `OperationScheduler`），否则会抛出异常。
+
 #### 回调监听
 
-```csharp
+OperationSystem **当前未提供**全局任务开始/结束回调的注册接口。
-/// <summary>
-/// 注册任务开始回调
-/// </summary>
-public static void RegisterStartCallback(Action<string, AsyncOperationBase> callback);
 
-/// <summary>
+如需监听任务结束（推荐），请直接订阅具体任务的 `Completed` 事件：
-/// 注册任务结束回调
-/// </summary>
-public static void RegisterFinishCallback(Action<string, AsyncOperationBase> callback);
-```
-
----
-
-### GameAsyncOperation（游戏层基类）
-
-继承 `AsyncOperationBase`，为业务层提供更友好的 API。
 
 ```csharp
-public abstract class GameAsyncOperation : AsyncOperationBase
+var operation = package.LoadAssetAsync<GameObject>(location);
+operation.Completed += op =>
 {
-    /// <summary>
+    // TODO : 根据 op.Status 判断成功/失败
-    /// 异步操作开始
+};
-    /// </summary>
-    protected abstract void OnStart();
-
-    /// <summary>
-    /// 异步操作更新
-    /// </summary>
-    protected abstract void OnUpdate();
-
-    /// <summary>
-    /// 异步操作终止
-    /// </summary>
-    protected abstract void OnAbort();
-
-    /// <summary>
-    /// 异步等待完成（可选重写）
-    /// </summary>
-    protected virtual void OnWaitForAsyncComplete();
-
-    /// <summary>
-    /// 异步操作系统是否繁忙
-    /// </summary>
-    protected bool IsBusy();
-
-    /// <summary>
-    /// 终止异步操作
-    /// </summary>
-    protected void Abort();
-}
 ```
 
 ---
@@ -339,15 +325,37 @@ void LoadAssetSync()
 
 操作按 `Priority` 属性降序排列，优先级高的操作先执行。
 
+#### 操作优先级
+
 ```csharp
 var operation = package.LoadAssetAsync<GameObject>(location);
 operation.Priority = 100;  // 设置高优先级
 ```
 
+#### 包裹优先级
+
+通过 `ResourcePackage.PackagePriority` 可以设置包裹的调度器优先级，值越大越优先更新。
+
+```csharp
+// 创建包裹时指定优先级
+var package = YooAssets.CreatePackage("MyPackage", 100);
+
+// 运行时动态调整优先级
+package.PackagePriority = 200;
+
+// 获取当前优先级
+uint priority = package.PackagePriority;
+```
+
+**使用场景：**
+- 多包裹场景下，可根据游戏状态动态调整包裹优先级
+- 例如：进入战斗时提高战斗资源包的优先级，退出战斗时恢复默认优先级
+
 **排序规则：**
-- 新操作添加时检查是否需要排序
+- 新操作添加时：若新增队列存在非零优先级，则触发排序
-- 仅当存在非零优先级时触发排序
+- 运行中修改 `Priority`：调度器会在每帧 `Update()` 的排序阶段检测 `IsDirty` 并触发重排；若在某个操作的 `InternalUpdate()` 内修改（本帧排序已完成），则新的优先级会延后一帧生效（可能与预期不符）
-- 使用 `List.Sort()` 进行原地排序
+- 若期望本帧生效：请尽量在任务入队前或本帧调度器 `Update()` 开始前设置 `Priority`，避免在 `InternalUpdate()` 内临时调整
+- 排序使用 `List.Sort()` 进行原地排序；频繁修改优先级会带来额外排序开销，建议按需使用
 
 ### 时间切片
 
@@ -358,6 +366,10 @@ operation.Priority = 100;  // 设置高优先级
 OperationSystem.MaxTimeSlice = 8;
 ```
 
+**操作侧协作建议：**
+- 在操作的 `InternalUpdate()` 中使用 `IsBusy`（`AsyncOperationBase` 的内部属性）进行“自愿让出”，将重任务拆分到多帧执行。
+- 在同步等待（`WaitForAsyncComplete()`）阶段，`IsBusy` 会强制返回 `false`，以保证同步等待推进；此时需要自行评估卡顿风险。
+
 **执行流程：**
 
 ```
@@ -420,24 +432,29 @@ OperationSystem.MaxTimeSlice = 8;
 ### 调试信息结构
 
 ```csharp
+[Serializable]
 internal struct DebugOperationInfo
 {
-    public string OperationName;   // 操作类型名
+    public string OperationName;   // 任务名称
-    public string OperationDesc;   // 操作描述
+    public string OperationDesc;   // 任务说明
     public uint Priority;          // 优先级
-    public float Progress;         // 进度
+    public float Progress;         // 任务进度
-    public string BeginTime;       // 开始时间
+    public string BeginTime;       // 任务开始的时间
-    public long ProcessTime;       // 处理耗时（毫秒）
+    public long ProcessTime;       // 处理耗时（单位：毫秒）
-    public string Status;          // 状态
+    public string Status;          // 任务状态
-    public List<DebugOperationInfo> Childs;  // 子操作
+    public List<DebugOperationInfo> Childs;  // 子任务列表（注意：JsonUtility 序列化深度限制）
 }
 ```
 
+> 说明：该结构体真实定义位于 `Runtime/DiagnosticSystem/DebugOperationInfo.cs`，这里仅展示关键字段以便理解。
+
 ### 获取调试信息
 
 ```csharp
-// 获取指定包裹的所有操作信息
+// 获取指定包裹的所有操作信息（内部调试接口）
-var infos = OperationSystem.GetDebugOperationInfos("DefaultPackage");
+// packageName 不允许为空；全局调度器请使用 OperationSystem.GLOBAL_SCHEDULER_NAME
+// 非全局包裹需先 YooAssets.CreatePackage(packageName)
+var infos = OperationSystem.GetDebugOperationInfos(OperationSystem.GLOBAL_SCHEDULER_NAME);
 
 foreach (var info in infos)
 {
@@ -457,105 +474,6 @@ Debug.Log($"处理耗时: {operation.ProcessTime}ms");
 
 ---
 
-## 使用示例
-
-### 自定义异步操作
-
-```csharp
-public class MyCustomOperation : GameAsyncOperation
-{
-    private int _step = 0;
-
-    protected override void OnStart()
-    {
-        // 初始化操作
-        _step = 0;
-    }
-
-    protected override void OnUpdate()
-    {
-        // 检查系统是否繁忙（时间切片）
-        if (IsBusy())
-            return;
-
-        // 执行步骤
-        switch (_step)
-        {
-            case 0:
-                // 第一步
-                Progress = 0.3f;
-                _step = 1;
-                break;
-            case 1:
-                // 第二步
-                Progress = 0.6f;
-                _step = 2;
-                break;
-            case 2:
-                // 完成
-                Status = EOperationStatus.Succeed;
-                break;
-        }
-    }
-
-    protected override void OnAbort()
-    {
-        // 清理资源
-    }
-}
-```
-
-### 启动自定义操作
-
-```csharp
-var operation = new MyCustomOperation();
-OperationSystem.StartOperation("DefaultPackage", operation);
-
-// 使用回调
-operation.Completed += (op) =>
-{
-    if (op.Status == EOperationStatus.Succeed)
-        Debug.Log("操作成功");
-};
-
-// 或使用 await
-await operation.Task;
-```
-
-### 带子任务的操作
-
-```csharp
-public class ParentOperation : GameAsyncOperation
-{
-    private ChildOperation _child;
-
-    protected override void OnStart()
-    {
-        _child = new ChildOperation();
-        AddChildOperation(_child);  // 添加子任务
-        OperationSystem.StartOperation(PackageName, _child);
-    }
-
-    protected override void OnUpdate()
-    {
-        if (_child.IsDone)
-        {
-            if (_child.Status == EOperationStatus.Succeed)
-                Status = EOperationStatus.Succeed;
-            else
-                Status = EOperationStatus.Failed;
-        }
-    }
-
-    protected override void OnAbort()
-    {
-        // 子任务会自动中止
-    }
-}
-```
-
----
-
 ## 设计模式
 
 ### 模板方法模式
@@ -589,7 +507,7 @@ AsyncOperationBase
 
 ### 组合模式
 
-通过 `Childs` 列表支持父子操作关系：
+通过内部子任务列表支持父子操作关系：
 
 ```
 ParentOperation
@@ -608,10 +526,6 @@ IEnumerator + IComparable<AsyncOperationBase>
               │
               ▼
     AsyncOperationBase (抽象基类)
-              │
-              ├── GameAsyncOperation (游戏层基类)
-              │         │
-              │         └── [业务层自定义操作]
               │
               └── [YooAsset 内部操作]
                       │
@@ -632,4 +546,4 @@ IEnumerator + IComparable<AsyncOperationBase>
 4. **子任务中止**：父操作中止时会自动中止所有子操作
 5. **回调异常**：`Completed` 回调中的异常会被捕获并记录，不会中断系统
 6. **编辑器重置**：编辑器中使用 `RuntimeInitializeOnLoadMethod` 自动重置状态
-7. **循环保护**：`WaitForAsyncComplete()` 有 1000 帧上限，防止无限循环
+7. **循环保护**：在 `InternalWaitForAsyncComplete()` 中建议使用 `RunBatchExecution()`（默认 1000 次）限制单次推进次数，避免陷入无限循环或长时间占用主线程

Assets/YooAsset/Runtime/ResourceManager/Operation/InstantiateOperation.cs

@@ -62,6 +62,9 @@ namespace YooAsset
                     return;
                 }
 
+                if (IsWaitForAsyncComplete)
+                    _handle.WaitForAsyncComplete();
+
                 if (_handle.IsDone == false)
                     return;
 
@@ -138,18 +141,7 @@ namespace YooAsset
         }
         internal override void InternalWaitForAsyncComplete()
         {
-            while (true)
+            RunBatchExecution();
-            {
-                // 等待句柄完成
-                if (_handle != null)
-                    _handle.WaitForAsyncComplete();
-
-                if (ExecuteWhileDone())
-                {
-                    _steps = ESteps.Done;
-                    break;
-                }
-            }
         }
         internal override string InternalGetDesc()
         {

Assets/YooAsset/Runtime/ResourceManager/Operation/Internal/LoadBundleFileOperation.cs

@@ -127,14 +127,7 @@ namespace YooAsset
         }
         internal override void InternalWaitForAsyncComplete()
         {
-            while (true)
+            RunBatchExecution();
-            {
-                if (ExecuteWhileDone())
-                {
-                    _steps = ESteps.Done;
-                    break;
-                }
-            }
         }
         internal override string InternalGetDesc()
         {

Assets/YooAsset/Runtime/ResourceManager/Operation/UnloadUnusedAssetsOperation.cs

@@ -53,14 +53,7 @@ namespace YooAsset
         }
         internal override void InternalWaitForAsyncComplete()
         {
-            while (true)
+            RunBatchExecution();
-            {
-                if (ExecuteWhileDone())
-                {
-                    _steps = ESteps.Done;
-                    break;
-                }
-            }
         }
         internal override string InternalGetDesc()
         {

Assets/YooAsset/Runtime/ResourceManager/Provider/ProviderOperation.cs

@@ -183,14 +183,7 @@ namespace YooAsset
         }
         internal override void InternalWaitForAsyncComplete()
         {
-            while (true)
+            RunBatchExecution();
-            {
-                if (ExecuteWhileDone())
-                {
-                    _steps = ESteps.Done;
-                    break;
-                }
-            }
         }
         internal override string InternalGetDesc()
         {

Assets/YooAsset/Runtime/ResourcePackage/EBuildBundleType.cs

@@ -22,5 +22,10 @@ namespace YooAsset
         /// 原生文件
         /// </summary>
         RawBundle = 3,
+        
+        /// <summary>
+        /// 团结资源包
+        /// </summary>
+        InstantBundle = 4,
     }
 }

Assets/YooAsset/Runtime/ResourcePackage/Operation/Internal/DeserializeManifestOperation.cs

@@ -220,14 +220,7 @@ namespace YooAsset
         }
         internal override void InternalWaitForAsyncComplete()
         {
-            while (true)
+            RunBatchExecution();
-            {
-                if (ExecuteWhileDone())
-                {
-                    _steps = ESteps.Done;
-                    break;
-                }
-            }
         }
 
         private void CreateAssetCollection(PackageManifest manifest, int assetCount)

Assets/YooAsset/Runtime/ResourcePackage/ResourcePackage.cs

@@ -44,6 +44,15 @@ namespace YooAsset
             }
         }
 
+        /// <summary>
+        /// 包裹优先级（值越大越优先更新）
+        /// </summary>
+        public uint PackagePriority
+        {
+            get { return OperationSystem.GetSchedulerPriority(PackageName); }
+            set { OperationSystem.SetSchedulerPriority(PackageName, value); }
+        }
+        
 
         internal ResourcePackage(string packageName)
         {
@@ -213,7 +222,7 @@ namespace YooAsset
             options.ReleaseAllHandles = true;
             options.LockLoadOperation = true;
             var operation = new DestroyOperation(this, options);
-            OperationSystem.StartOperation(null, operation);
+            OperationSystem.StartOperation(OperationSystem.GLOBAL_SCHEDULER_NAME, operation);
             return operation;
         }
 

Assets/YooAsset/Runtime/Utility/YooUtility.cs

@@ -5,6 +5,27 @@ using System.Text;
 
 namespace YooAsset
 {
+    /// <summary>
+    /// 时间工具类
+    /// </summary>
+    internal static class TimeUtility
+    {
+        /// <summary>
+        /// The real time in seconds since the game started
+        /// </summary>
+        public static double RealtimeSinceStartup
+        {
+            get
+            {
+#if UNITY_2020_3_OR_NEWER
+                return UnityEngine.Time.realtimeSinceStartupAsDouble;
+#else
+                return UnityEngine.Time.realtimeSinceStartup;
+#endif
+            }
+        }
+    }
+
     /// <summary>
     /// 路径工具类
     /// </summary>

Assets/YooAsset/Runtime/YooAssets.cs

@@ -59,6 +59,7 @@ namespace YooAsset
                 _driver.AddComponent<RemoteDebuggerInRuntime>();
 #endif
 
+                // 初始化异步操作系统
                 OperationSystem.Initialize();
             }
         }
@@ -75,8 +76,8 @@ namespace YooAsset
                 if (_driver != null)
                     GameObject.Destroy(_driver);
 
-                // 终止并清空所有包裹的异步操作
+                // 销毁异步操作系统
-                ClearAllPackageOperation();
+                OperationSystem.DestroyAll();
 
                 // 卸载所有AssetBundle
                 AssetBundle.UnloadAllAssetBundles(true);
@@ -97,18 +98,6 @@ namespace YooAsset
             }
         }
 
-        /// <summary>
-        /// 终止并清空所有包裹的异步操作
-        /// </summary>
-        internal static void ClearAllPackageOperation()
-        {
-            foreach (var package in _packages)
-            {
-                OperationSystem.ClearPackageOperation(package.PackageName);
-            }
-            OperationSystem.DestroyAll();
-        }
-
         /// <summary>
         /// 创建资源包裹
         /// </summary>
@@ -123,7 +112,7 @@ namespace YooAsset
         /// </summary>
         /// <param name="packageName">包裹名称</param>
         /// <param name="packagePriority">包裹优先级（值越大越优先更新）</param>
-        public static ResourcePackage CreatePackage(string packageName, int packagePriority)
+        public static ResourcePackage CreatePackage(string packageName, uint packagePriority)
         {
             CheckException(packageName);
             if (ContainsPackage(packageName))
@@ -225,7 +214,7 @@ namespace YooAsset
         public static void StartOperation(GameAsyncOperation operation)
         {
             // 注意：游戏业务逻辑的包裹填写为空
-            OperationSystem.StartOperation(string.Empty, operation);
+            OperationSystem.StartOperation(OperationSystem.GLOBAL_SCHEDULER_NAME, operation);
         }
 
 

Assets/YooAsset/Runtime/YooAssetsDriver.cs

@@ -25,7 +25,7 @@ namespace YooAsset
         void OnApplicationQuit()
         {
             // 说明：在编辑器下确保播放被停止时IO类操作被终止。
-            YooAssets.ClearAllPackageOperation();
+            YooAssets.Destroy();
         }
 #endif