优化资源模块性能

缓存命中的异步加载不再额外 Yield 一帧
改成按进度增量触发，避免每帧无意义 delegate 调用
减少了高频换图时的小对象分配

Runtime/Resource/Resource/Extension/ResourceExtComponent.Resource.cs

@@ -8,17 +8,20 @@ namespace AlicizaX.Resource.Runtime
     public partial class ResourceExtComponent
     {
         private static IResourceModule _resourceModule;
-        private LoadAssetCallbacks _loadAssetCallbacks;
 
         public static IResourceModule ResourceModule => _resourceModule;
 
         private class LoadingState : IMemory
         {
             public CancellationTokenSource Cts { get; set; }
+            public CancellationTokenRegistration Registration { get; set; }
             public string Location { get; set; }
 
             public void Clear()
             {
+                Registration.Dispose();
+                Registration = default;
+
                 if (Cts != null)
                 {
                     Cts.Cancel();
@@ -26,64 +29,44 @@ namespace AlicizaX.Resource.Runtime
                     Cts = null;
                 }
 
-                Location = String.Empty;
+                Location = string.Empty;
             }
         }
 
-        private static readonly Dictionary<UnityEngine.Object, LoadingState> _loadingStates = new Dictionary<UnityEngine.Object, LoadingState>();
+        private readonly Dictionary<UnityEngine.Object, LoadingState> _loadingStates = new Dictionary<UnityEngine.Object, LoadingState>();
 
         private void InitializedResources()
         {
             _resourceModule = ModuleSystem.GetModule<IResourceModule>();
-            _loadAssetCallbacks = new LoadAssetCallbacks(OnLoadAssetSuccess, OnLoadAssetFailure);
-        }
-
-        private void OnLoadAssetFailure(string assetName, LoadResourceStatus status, string errormessage, object userdata)
-        {
-            _assetLoadingList.Remove(assetName);
-            ISetAssetObject setAssetObject = (ISetAssetObject)userdata;
-            if (setAssetObject != null)
-            {
-                ClearLoadingState(setAssetObject.TargetObject);
-            }
-
-            Log.Error("Can not load asset from '{0}' with error message '{1}'.", assetName, errormessage);
         }
 
         private void OnLoadAssetSuccess(string assetName, object asset, float duration, object userdata)
         {
-            _assetLoadingList.Remove(assetName);
             ISetAssetObject setAssetObject = (ISetAssetObject)userdata;
-            UnityEngine.Object assetObject = asset as UnityEngine.Object;
-
-            if (assetObject != null)
+            if (setAssetObject == null)
             {
-                // 检查资源是否仍然是当前需要的。
-                if (IsCurrentLocation(setAssetObject.TargetObject, setAssetObject.Location))
-                {
-                    ClearLoadingState(setAssetObject.TargetObject);
+                return;
+            }
 
-                    _assetItemPool.Register(AssetItemObject.Create(setAssetObject.Location, assetObject), true);
-                    SetAsset(setAssetObject, assetObject);
-                }
-                else
-                {
-                    // 资源已经过期，卸载。
-                    _resourceModule.UnloadAsset(assetObject);
-                }
+            UnityEngine.Object assetObject = asset as UnityEngine.Object;
+            if (assetObject == null)
+            {
+                Log.Error($"Load failure asset type is {asset?.GetType()}.");
+                return;
+            }
+
+            if (IsCurrentLocation(setAssetObject.TargetObject, setAssetObject.Location))
+            {
+                ClearLoadingState(setAssetObject.TargetObject);
+                SetAsset(setAssetObject, TrackLoadedAsset(setAssetObject.Location, assetObject));
             }
             else
             {
-                Log.Error($"Load failure asset type is {asset.GetType()}.");
+                _resourceModule.UnloadAsset(assetObject);
             }
         }
 
-        /// <summary>
-        /// 通过Unity对象加载资源。
-        /// </summary>
-        /// <param name="setAssetObject">ISetAssetObject。</param>
-        /// <typeparam name="T">Unity对象类型。</typeparam>
-        public async UniTaskVoid SetAssetByResources<T>(ISetAssetObject setAssetObject,CancellationToken cancellationToken) where T : UnityEngine.Object
+        public async UniTaskVoid SetAssetByResources<T>(ISetAssetObject setAssetObject, CancellationToken cancellationToken) where T : UnityEngine.Object
         {
             var target = setAssetObject.TargetObject;
             var location = setAssetObject.Location;
@@ -93,62 +76,55 @@ namespace AlicizaX.Resource.Runtime
                 return;
             }
 
-            // 取消并清理旧的加载请求。
             CancelAndCleanupOldRequest(target);
 
-            // 创建新的加载状态
-            var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+            var linkedTokenSource = new CancellationTokenSource();
             var loadingState = MemoryPool.Acquire<LoadingState>();
             loadingState.Cts = linkedTokenSource;
+            if (cancellationToken.CanBeCanceled)
+            {
+                loadingState.Registration = cancellationToken.Register(static state =>
+                {
+                    ((CancellationTokenSource)state).Cancel();
+                }, linkedTokenSource);
+            }
+
             loadingState.Location = location;
             _loadingStates[target] = loadingState;
 
             try
             {
-                // 等待其他可能正在进行的加载。
-                await TryWaitingLoading(location).AttachExternalCancellation(linkedTokenSource.Token);
-
-                // 再次检查是否被新请求替换。
                 if (!IsCurrentLocation(target, location))
                 {
                     return;
                 }
 
-                // 检查缓存。
                 if (_assetItemPool.CanSpawn(location))
                 {
                     ClearLoadingState(target);
 
                     var assetObject = (T)_assetItemPool.Spawn(location).Target;
                     SetAsset(setAssetObject, assetObject);
+                    return;
                 }
-                else
+
+                if (!IsCurrentLocation(target, location))
                 {
-                    // 最后一次检查是否被替换。
-                    if (!IsCurrentLocation(target, location))
-                    {
-                        return;
-                    }
-
-                    // 防止重复加载同一资源。
-                    if (!_assetLoadingList.Add(location))
-                    {
-                        // 已经在加载中，等待回调处理。
-                        return;
-                    }
-
-                    T resource = await _resourceModule.LoadAssetAsync<T>(location, linkedTokenSource.Token);
-                    if (resource != null)
-                    {
-                        _loadAssetCallbacks?.LoadAssetSuccessCallback.Invoke(location,resource, 0f, setAssetObject);
-
-                    }
-                    _assetLoadingList.Remove(location);
+                    return;
                 }
+
+                T resource = await _resourceModule.LoadAssetAsync<T>(location, linkedTokenSource.Token);
+                if (resource == null)
+                {
+                    ClearLoadingState(target);
+                    return;
+                }
+
+                OnLoadAssetSuccess(location, resource, 0f, setAssetObject);
             }
             catch (OperationCanceledException)
             {
-                // 请求被取消，正常情况，无需处理。
+                ClearLoadingState(target);
             }
             catch (Exception ex)
             {
@@ -157,10 +133,6 @@ namespace AlicizaX.Resource.Runtime
             }
         }
 
-        /// <summary>
-        /// 取消并清理旧的加载请求。
-        /// <param name="target">Unity对象。</param>
-        /// </summary>
         private void CancelAndCleanupOldRequest(UnityEngine.Object target)
         {
             if (_loadingStates.TryGetValue(target, out var oldState))
@@ -170,10 +142,6 @@ namespace AlicizaX.Resource.Runtime
             }
         }
 
-        /// <summary>
-        /// 清理加载状态。
-        /// <param name="target">Unity对象。</param>
-        /// </summary>
         private void ClearLoadingState(UnityEngine.Object target)
         {
             if (_loadingStates.TryGetValue(target, out var state))
@@ -183,23 +151,33 @@ namespace AlicizaX.Resource.Runtime
             }
         }
 
-        /// <summary>
-        /// 检查指定位置是否仍是该目标的当前加载位置。
-        /// </summary>
         private bool IsCurrentLocation(UnityEngine.Object target, string location)
         {
             if (target == null)
             {
                 return false;
             }
+
             return _loadingStates.TryGetValue(target, out var state) && state.Location == location;
         }
 
-        /// <summary>
-        /// 组件销毁时清理所有资源。
-        /// </summary>
+        private UnityEngine.Object TrackLoadedAsset(string location, UnityEngine.Object assetObject)
+        {
+            if (_assetItemPool.CanSpawn(location))
+            {
+                var cachedAsset = _assetItemPool.Spawn(location).Target as UnityEngine.Object;
+                _resourceModule.UnloadAsset(assetObject);
+                return cachedAsset;
+            }
+
+            _assetItemPool.Register(AssetItemObject.Create(location, assetObject), true);
+            return assetObject;
+        }
+
         private void OnDestroy()
         {
+            ReleaseTrackedAssets();
+
             foreach (var state in _loadingStates.Values)
             {
                 MemoryPool.Release(state);
@@ -208,4 +186,4 @@ namespace AlicizaX.Resource.Runtime
             _loadingStates.Clear();
         }
     }
-}
+}

Runtime/Resource/Resource/Extension/ResourceExtComponent.SubSprite.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Threading;
 using Cysharp.Threading.Tasks;
 using UnityEngine;
@@ -14,6 +15,7 @@ namespace AlicizaX.Resource.Runtime
     {
         private readonly Dictionary<string, SubAssetsHandle> _subAssetsHandles = new Dictionary<string, SubAssetsHandle>();
         private readonly Dictionary<string, int> _subSpriteReferences = new Dictionary<string, int>();
+        private readonly Dictionary<string, UniTaskCompletionSource<SubAssetsHandle>> _subAssetLoadingOperations = new Dictionary<string, UniTaskCompletionSource<SubAssetsHandle>>();
 
         public async UniTask SetSubSprite(Image image, string location, string spriteName, bool setNativeSize = false, CancellationToken cancellationToken = default)
         {
@@ -22,6 +24,7 @@ namespace AlicizaX.Resource.Runtime
             if (image == null)
             {
                 Log.Warning($"SetSubAssets Image is null");
+                ReleaseSubAssetsIfUnused(location);
                 return;
             }
 
@@ -41,6 +44,7 @@ namespace AlicizaX.Resource.Runtime
             if (spriteRenderer == null)
             {
                 Log.Warning($"SetSubAssets Image is null");
+                ReleaseSubAssetsIfUnused(location);
                 return;
             }
 
@@ -56,14 +60,7 @@ namespace AlicizaX.Resource.Runtime
                 throw new GameFrameworkException($"Invalid location: {location}");
             }
 
-            await TryWaitingLoading(location);
-
-            if (!_subAssetsHandles.TryGetValue(location, out var subAssetsHandle))
-            {
-                subAssetsHandle = YooAssets.LoadSubAssetsAsync<Sprite>(location);
-                await subAssetsHandle.ToUniTask(cancellationToken: cancellationToken);
-                _subAssetsHandles[location] = subAssetsHandle;
-            }
+            var subAssetsHandle = await GetOrLoadSubAssetsHandleAsync(location, cancellationToken);
 
             var subSprite = subAssetsHandle.GetSubAssetObject<Sprite>(spriteName);
             if (subSprite == null)
@@ -82,8 +79,10 @@ namespace AlicizaX.Resource.Runtime
                 subSpriteReference = target.AddComponent<SubSpriteReference>();
             }
 
-            _subSpriteReferences[location] = _subSpriteReferences.TryGetValue(location, out var count) ? count + 1 : 1;
-            subSpriteReference.Reference(location);
+            if (subSpriteReference.Reference(location))
+            {
+                _subSpriteReferences[location] = _subSpriteReferences.TryGetValue(location, out var count) ? count + 1 : 1;
+            }
         }
 
         internal void DeleteReference(string location)
@@ -93,13 +92,85 @@ namespace AlicizaX.Resource.Runtime
                 return;
             }
 
-            _subSpriteReferences[location] = _subSpriteReferences.TryGetValue(location, out var count) ? count - 1 : 0;
-            if (_subSpriteReferences[location] <= 0)
+            int nextCount = _subSpriteReferences.TryGetValue(location, out var count) ? count - 1 : 0;
+            if (nextCount > 0)
+            {
+                _subSpriteReferences[location] = nextCount;
+                return;
+            }
+
+            _subSpriteReferences.Remove(location);
+            if (_subAssetsHandles.TryGetValue(location, out var subAssetsHandle))
+            {
+                subAssetsHandle.Dispose();
+                _subAssetsHandles.Remove(location);
+            }
+        }
+
+        private async UniTask<SubAssetsHandle> GetOrLoadSubAssetsHandleAsync(string location, CancellationToken cancellationToken)
+        {
+            while (true)
+            {
+                if (_subAssetsHandles.TryGetValue(location, out var cachedHandle))
+                {
+                    return cachedHandle;
+                }
+
+                if (_subAssetLoadingOperations.TryGetValue(location, out var loadingOperation))
+                {
+                    if (cancellationToken.CanBeCanceled)
+                    {
+                        await loadingOperation.Task.AttachExternalCancellation(cancellationToken);
+                    }
+                    else
+                    {
+                        await loadingOperation.Task;
+                    }
+
+                    continue;
+                }
+
+                var completionSource = new UniTaskCompletionSource<SubAssetsHandle>();
+                _subAssetLoadingOperations.Add(location, completionSource);
+
+                SubAssetsHandle subAssetsHandle = default;
+                try
+                {
+                    subAssetsHandle = YooAssets.LoadSubAssetsAsync<Sprite>(location);
+                    await subAssetsHandle.ToUniTask();
+                    _subAssetsHandles[location] = subAssetsHandle;
+                    completionSource.TrySetResult(subAssetsHandle);
+                    return subAssetsHandle;
+                }
+                catch (Exception ex)
+                {
+                    subAssetsHandle?.Dispose();
+                    completionSource.TrySetException(ex);
+                    throw;
+                }
+                finally
+                {
+                    _subAssetLoadingOperations.Remove(location);
+                }
+            }
+        }
+
+        private void ReleaseSubAssetsIfUnused(string location)
+        {
+            if (string.IsNullOrEmpty(location))
+            {
+                return;
+            }
+
+            if (_subSpriteReferences.TryGetValue(location, out var count) && count > 0)
+            {
+                return;
+            }
+
+            if (_subAssetsHandles.TryGetValue(location, out var subAssetsHandle))
             {
-                var subAssetsHandle = _subAssetsHandles[location];
                 subAssetsHandle.Dispose();
                 _subAssetsHandles.Remove(location);
-                _subSpriteReferences.Remove(location);
             }
         }
     }
@@ -109,14 +180,20 @@ namespace AlicizaX.Resource.Runtime
     {
         private string _location;
 
-        public void Reference(string location)
+        public bool Reference(string location)
         {
+            if (_location == location)
+            {
+                return false;
+            }
+
             if (_location != null && _location != location)
             {
                 ResourceExtComponent.Instance?.DeleteReference(_location);
             }
 
             _location = location;
+            return true;
         }
 
         private void OnDestroy()

Runtime/Resource/Resource/Extension/ResourceExtComponent.cs

@@ -17,13 +17,6 @@ namespace AlicizaX.Resource.Runtime
     {
         public static ResourceExtComponent Instance { private set; get; }
 
-        private readonly TimeoutController _timeoutController = new TimeoutController();
-
-        /// <summary>
-        /// 正在加载的资源列表。
-        /// </summary>
-        private readonly HashSet<string> _assetLoadingList = new HashSet<string>();
-
         /// <summary>
         /// 检查是否可以释放间隔。
         /// </summary>
@@ -54,6 +47,8 @@ namespace AlicizaX.Resource.Runtime
         /// </summary>
         private LinkedList<LoadAssetObject> _loadAssetObjectsLinkedList;
 
+        private Dictionary<Object, LinkedListNode<LoadAssetObject>> _trackedAssetNodes;
+
         /// <summary>
         /// 散图集合对象池。
         /// </summary>
@@ -76,6 +71,7 @@ namespace AlicizaX.Resource.Runtime
                 "SetAssetPool",
                 autoReleaseInterval, 16, 60, 0);
             _loadAssetObjectsLinkedList = new LinkedList<LoadAssetObject>();
+            _trackedAssetNodes = new Dictionary<Object, LinkedListNode<LoadAssetObject>>(16);
 
             InitializedResources();
         }
@@ -120,9 +116,7 @@ namespace AlicizaX.Resource.Runtime
 
                 if (current.Value.AssetObject.IsCanRelease())
                 {
-                    _assetItemPool.Unspawn(current.Value.AssetTarget);
-                    MemoryPool.Release(current.Value.AssetObject);
-                    _loadAssetObjectsLinkedList.Remove(current);
+                    RemoveTrackedNode(current, releaseAsset: true);
                 }
 
                 current = next;
@@ -141,33 +135,78 @@ namespace AlicizaX.Resource.Runtime
 
         private void SetAsset(ISetAssetObject setAssetObject, Object assetObject)
         {
-            _loadAssetObjectsLinkedList.AddLast(new LoadAssetObject(setAssetObject, assetObject));
+            ReplaceTrackedAsset(setAssetObject.TargetObject);
+
+            var node = _loadAssetObjectsLinkedList.AddLast(new LoadAssetObject(setAssetObject, assetObject));
+            if (setAssetObject.TargetObject != null)
+            {
+                _trackedAssetNodes[setAssetObject.TargetObject] = node;
+            }
+
             setAssetObject.SetAsset(assetObject);
         }
 
-        private async UniTask TryWaitingLoading(string assetObjectKey)
+        private void ReplaceTrackedAsset(Object target)
         {
-            if (_assetLoadingList.Contains(assetObjectKey))
+            if (target == null || _trackedAssetNodes == null)
             {
-                try
-                {
-                    await UniTask.WaitUntil(
-                            () => !_assetLoadingList.Contains(assetObjectKey))
-#if UNITY_EDITOR
-                        .AttachExternalCancellation(_timeoutController.Timeout(TimeSpan.FromSeconds(60)));
-                    _timeoutController.Reset();
-#else
-                    ;
-#endif
-                }
-                catch (OperationCanceledException ex)
-                {
-                    if (_timeoutController.IsTimeout())
-                    {
-                        Log.Error($"LoadAssetAsync Waiting {assetObjectKey} timeout. reason:{ex.Message}");
-                    }
-                }
+                return;
             }
+
+            if (_trackedAssetNodes.TryGetValue(target, out var existingNode))
+            {
+                if (_currentProcessNode == existingNode)
+                {
+                    _currentProcessNode = existingNode.Next;
+                }
+
+                RemoveTrackedNode(existingNode, releaseAsset: true);
+            }
+        }
+
+        private void RemoveTrackedNode(LinkedListNode<LoadAssetObject> node, bool releaseAsset)
+        {
+            if (node == null)
+            {
+                return;
+            }
+
+            var trackedObject = node.Value.AssetObject?.TargetObject;
+            if (trackedObject != null && _trackedAssetNodes != null)
+            {
+                _trackedAssetNodes.Remove(trackedObject);
+            }
+
+            if (releaseAsset && node.Value.AssetTarget != null && _assetItemPool != null)
+            {
+                _assetItemPool.Unspawn(node.Value.AssetTarget);
+            }
+
+            if (node.Value.AssetObject != null)
+            {
+                MemoryPool.Release(node.Value.AssetObject);
+            }
+
+            _loadAssetObjectsLinkedList?.Remove(node);
+        }
+
+        private void ReleaseTrackedAssets()
+        {
+            if (_loadAssetObjectsLinkedList == null)
+            {
+                return;
+            }
+
+            var current = _loadAssetObjectsLinkedList.First;
+            while (current != null)
+            {
+                var next = current.Next;
+                RemoveTrackedNode(current, releaseAsset: true);
+                current = next;
+            }
+
+            _currentProcessNode = null;
+            _trackedAssetNodes?.Clear();
         }
     }
 }

Runtime/Resource/Resource/Reference/AssetsReference.cs

@@ -29,69 +29,61 @@ namespace AlicizaX.Resource.Runtime
         private List<AssetsRefInfo> refAssetInfoList;
 
         private static IResourceModule _resourceModule;
+        private HashSet<int> _refAssetIds;
 
-        private static Dictionary<GameObject, AssetsReference> _originalRefs = new();
-
-
-        private void CheckInit()
+        private bool TryEnsureResourceModule()
         {
             if (_resourceModule != null)
             {
-                return;
-            }
-            else
-            {
-                _resourceModule = ModuleSystem.GetModule<IResourceModule>();
+                return true;
             }
 
-            if (_resourceModule == null)
-            {
-                throw new GameFrameworkException($"resourceModule is null.");
-            }
+            _resourceModule = ModuleSystem.GetModule<IResourceModule>();
+            return _resourceModule != null;
         }
 
-        private void CheckRelease()
+        private void ReleaseSourceReference()
         {
             if (sourceGameObject != null)
             {
                 _resourceModule.UnloadAsset(sourceGameObject);
+                sourceGameObject = null;
             }
-            else
+        }
+
+        private void EnsureReferenceCache()
+        {
+            if (_refAssetIds != null)
             {
-                Log.Warning($"sourceGameObject is not invalid.");
+                return;
             }
-        }
 
-
-        private void Awake()
-        {
-            // If it is a clone, clear the reference records before cloning
-            if (!IsOriginalInstance())
+            _refAssetIds = new HashSet<int>();
+            if (refAssetInfoList == null)
             {
-                ClearCloneReferences();
+                return;
             }
-        }
 
-        private bool IsOriginalInstance()
-        {
-            return _originalRefs.TryGetValue(gameObject, out var originalComponent) &&
-                   originalComponent == this;
-        }
-
-        private void ClearCloneReferences()
-        {
-            sourceGameObject = null;
-            refAssetInfoList?.Clear();
+            foreach (var refInfo in refAssetInfoList)
+            {
+                if (refInfo.refAsset != null)
+                {
+                    _refAssetIds.Add(refInfo.instanceId != 0 ? refInfo.instanceId : refInfo.refAsset.GetInstanceID());
+                }
+            }
         }
 
         private void OnDestroy()
         {
-            CheckInit();
-            if (sourceGameObject != null)
+            if (!TryEnsureResourceModule())
             {
-                CheckRelease();
+                sourceGameObject = null;
+                refAssetInfoList?.Clear();
+                _refAssetIds?.Clear();
+                return;
             }
 
+            ReleaseSourceReference();
             ReleaseRefAssetInfoList();
         }
 
@@ -106,6 +98,8 @@ namespace AlicizaX.Resource.Runtime
 
                 refAssetInfoList.Clear();
             }
+
+            _refAssetIds?.Clear();
         }
 
         public AssetsReference Ref(GameObject source, IResourceModule resourceModule = null)
@@ -120,14 +114,17 @@ namespace AlicizaX.Resource.Runtime
                 throw new GameFrameworkException($"Source gameObject is in scene.");
             }
 
-            _resourceModule = resourceModule;
-            sourceGameObject = source;
-
-            if (!_originalRefs.ContainsKey(gameObject))
+            if (resourceModule != null)
             {
-                _originalRefs.Add(gameObject, this);
+                _resourceModule = resourceModule;
             }
 
+            if (sourceGameObject != null && sourceGameObject != source && TryEnsureResourceModule())
+            {
+                ReleaseSourceReference();
+            }
+
+            sourceGameObject = source;
             return this;
         }
 
@@ -138,7 +135,18 @@ namespace AlicizaX.Resource.Runtime
                 throw new GameFrameworkException($"Source gameObject is null.");
             }
 
-            _resourceModule = resourceModule;
+            if (resourceModule != null)
+            {
+                _resourceModule = resourceModule;
+            }
+
+            EnsureReferenceCache();
+            int instanceId = source.GetInstanceID();
+            if (!_refAssetIds.Add(instanceId))
+            {
+                return this;
+            }
+
             if (refAssetInfoList == null)
             {
                 refAssetInfoList = new List<AssetsRefInfo>();

Runtime/Resource/Resource/ResourceComponent.cs

@@ -28,12 +28,16 @@ namespace AlicizaX.Resource.Runtime
 
         private float _lastUnloadUnusedAssetsOperationElapseSeconds = 0f;
 
+        private float _lastGCCollectElapseSeconds = float.MaxValue;
+
         [SerializeField] private float minUnloadUnusedAssetsInterval = 60f;
 
         [SerializeField] private float maxUnloadUnusedAssetsInterval = 300f;
 
         [SerializeField] private bool useSystemUnloadUnusedAssets = true;
 
+        [SerializeField] private float minGCCollectInterval = 30f;
+
         [SerializeField] private string decryptionServices = "";
 
         /// <summary>
@@ -239,6 +243,7 @@ namespace AlicizaX.Resource.Runtime
         private void Update()
         {
             _lastUnloadUnusedAssetsOperationElapseSeconds += Time.unscaledDeltaTime;
+            _lastGCCollectElapseSeconds += Time.unscaledDeltaTime;
             if (_asyncOperation == null && (_forceUnloadUnusedAssets || _lastUnloadUnusedAssetsOperationElapseSeconds >= maxUnloadUnusedAssetsInterval ||
                                             _preorderUnloadUnusedAssets && _lastUnloadUnusedAssetsOperationElapseSeconds >= minUnloadUnusedAssetsInterval))
             {
@@ -246,11 +251,13 @@ namespace AlicizaX.Resource.Runtime
                 _forceUnloadUnusedAssets = false;
                 _preorderUnloadUnusedAssets = false;
                 _lastUnloadUnusedAssetsOperationElapseSeconds = 0f;
-                _asyncOperation = Resources.UnloadUnusedAssets();
-                if (useSystemUnloadUnusedAssets)
-                {
-                    _resourceModule.UnloadUnusedAssets();
-                }
+                _resourceModule.UnloadUnusedAssets();
+                _asyncOperation = useSystemUnloadUnusedAssets ? Resources.UnloadUnusedAssets() : null;
+            }
+
+            if (_asyncOperation == null && _performGCCollect)
+            {
+                TryCollectGarbage();
             }
 
             if (_asyncOperation is { isDone: true })
@@ -258,13 +265,24 @@ namespace AlicizaX.Resource.Runtime
                 _asyncOperation = null;
                 if (_performGCCollect)
                 {
-                    Log.Info("GC.Collect...");
-                    _performGCCollect = false;
-                    GC.Collect();
+                    TryCollectGarbage();
                 }
             }
         }
 
+        private void TryCollectGarbage()
+        {
+            if (_lastGCCollectElapseSeconds < minGCCollectInterval)
+            {
+                return;
+            }
+
+            Log.Info("GC.Collect...");
+            _performGCCollect = false;
+            _lastGCCollectElapseSeconds = 0f;
+            GC.Collect();
+        }
+
         private void OnLowMemory()
         {
             Log.Warning("Low memory reported...");

Runtime/Resource/Resource/ResourceModule.cs

@@ -85,9 +85,11 @@ namespace AlicizaX.Resource.Runtime
         private readonly Dictionary<string, AssetInfo> _assetInfoMap = new Dictionary<string, AssetInfo>();
 
         /// <summary>
-        /// 正在加载的资源列表。
+        /// 正在加载的资源任务。
         /// </summary>
-        private readonly HashSet<string> _assetLoadingList = new HashSet<string>();
+        private readonly Dictionary<string, UniTaskCompletionSource<bool>> _assetLoadingOperations = new Dictionary<string, UniTaskCompletionSource<bool>>();
+
+        private const float ProgressCallbackThreshold = 0.01f;
 
         #endregion
 
@@ -107,6 +109,7 @@ namespace AlicizaX.Resource.Runtime
             }
 
             DefaultPackage = defaultPackage;
+            PackageMap[packageName] = defaultPackage;
 
             IObjectPoolModule objectPoolModule = ModuleSystem.GetModule<IObjectPoolModule>();
             SetObjectPoolModule(objectPoolModule);
@@ -115,9 +118,14 @@ namespace AlicizaX.Resource.Runtime
 
         void IModule.Dispose()
         {
+            foreach (var loadingOperation in _assetLoadingOperations.Values)
+            {
+                loadingOperation.TrySetResult(false);
+            }
+
             PackageMap.Clear();
             _assetPool = null;
-            _assetLoadingList.Clear();
+            _assetLoadingOperations.Clear();
             _assetInfoMap.Clear();
         }
 
@@ -463,7 +471,7 @@ namespace AlicizaX.Resource.Runtime
 
             AssetInfo assetInfo = GetAssetInfo(location, packageName);
 
-            if (!CheckLocationValid(location))
+            if (!CheckLocationValid(location, packageName))
             {
                 return HasAssetResult.Valid;
             }
@@ -535,20 +543,25 @@ namespace AlicizaX.Resource.Runtime
         /// <param name="packageName">指定资源包的名称。不传使用默认资源包</param>
         /// <typeparam name="T">资源类型。</typeparam>
         /// <returns>资源句柄。</returns>
-        private AssetHandle GetHandleAsync<T>(string location, string packageName = "") where T : UnityEngine.Object
+        private AssetHandle GetHandleAsync<T>(string location, string packageName = "", uint priority = 0) where T : UnityEngine.Object
         {
-            return GetHandleAsync(location, typeof(T), packageName);
+            return GetHandleAsync(location, typeof(T), packageName, priority);
         }
 
-        private AssetHandle GetHandleAsync(string location, Type assetType, string packageName = "")
+        private AssetHandle GetHandleAsync(string location, Type assetType, string packageName = "", uint priority = 0)
         {
             if (string.IsNullOrEmpty(packageName))
             {
-                return YooAssets.LoadAssetAsync(location, assetType);
+                return YooAssets.LoadAssetAsync(location, assetType, priority);
             }
 
             var package = YooAssets.GetPackage(packageName);
-            return package.LoadAssetAsync(location, assetType);
+            return package.LoadAssetAsync(location, assetType, priority);
+        }
+
+        private static uint NormalizePriority(int priority)
+        {
+            return priority > 0 ? (uint)priority : 0u;
         }
 
         #endregion
@@ -652,37 +665,16 @@ namespace AlicizaX.Resource.Runtime
             }
 
             string assetObjectKey = GetCacheKey(location, packageName);
-
-            await TryWaitingLoading(assetObjectKey);
-
-            AssetObject assetObject = _assetPool.Spawn(assetObjectKey);
-            if (assetObject != null)
+            try
             {
-                await UniTask.Yield();
-                callback?.Invoke(assetObject.Target as T);
-                return;
+                var asset = await GetOrLoadAssetAsync(location, typeof(T), packageName, assetObjectKey);
+                callback?.Invoke(asset as T);
             }
-
-            _assetLoadingList.Add(assetObjectKey);
-
-            AssetHandle handle = GetHandleAsync<T>(location, packageName: packageName);
-
-            handle.Completed += assetHandle =>
+            catch (Exception ex)
             {
-                _assetLoadingList.Remove(assetObjectKey);
-
-                if (assetHandle.AssetObject != null)
-                {
-                    assetObject = AssetObject.Create(assetObjectKey, handle.AssetObject, handle, this);
-                    _assetPool.Register(assetObject, true);
-
-                    callback?.Invoke(assetObject.Target as T);
-                }
-                else
-                {
-                    callback?.Invoke(null);
-                }
-            };
+                Log.Error($"Can not load asset '{location}'. {ex}");
+                callback?.Invoke(null);
+            }
         }
 
         public async UniTask<T> LoadAssetAsync<T>(string location, CancellationToken cancellationToken = default, string packageName = "") where T : UnityEngine.Object
@@ -701,33 +693,8 @@ namespace AlicizaX.Resource.Runtime
 
             string assetObjectKey = GetCacheKey(location, packageName);
 
-            await TryWaitingLoading(assetObjectKey);
-
-            AssetObject assetObject = _assetPool.Spawn(assetObjectKey);
-            if (assetObject != null)
-            {
-                await UniTask.Yield();
-                return assetObject.Target as T;
-            }
-
-            _assetLoadingList.Add(assetObjectKey);
-
-            AssetHandle handle = GetHandleAsync<T>(location, packageName: packageName);
-
-            bool cancelOrFailed = await handle.ToUniTask().AttachExternalCancellation(cancellationToken).SuppressCancellationThrow();
-
-            if (cancelOrFailed)
-            {
-                _assetLoadingList.Remove(assetObjectKey);
-                return null;
-            }
-
-            assetObject = AssetObject.Create(assetObjectKey, handle.AssetObject, handle, this);
-            _assetPool.Register(assetObject, true);
-
-            _assetLoadingList.Remove(assetObjectKey);
-
-            return handle.AssetObject as T;
+            var asset = await GetOrLoadAssetAsync(location, typeof(T), packageName, assetObjectKey, cancellationToken: cancellationToken);
+            return asset as T;
         }
 
         public async UniTask<GameObject> LoadGameObjectAsync(string location, Transform parent = null, CancellationToken cancellationToken = default, string packageName = "")
@@ -745,35 +712,8 @@ namespace AlicizaX.Resource.Runtime
 
             string assetObjectKey = GetCacheKey(location, packageName);
 
-            await TryWaitingLoading(assetObjectKey);
-
-            AssetObject assetObject = _assetPool.Spawn(assetObjectKey);
-            if (assetObject != null)
-            {
-                await UniTask.Yield();
-                return AssetsReference.Instantiate(assetObject.Target as GameObject, parent, this).gameObject;
-            }
-
-            _assetLoadingList.Add(assetObjectKey);
-
-            AssetHandle handle = GetHandleAsync<GameObject>(location, packageName: packageName);
-
-            bool cancelOrFailed = await handle.ToUniTask().AttachExternalCancellation(cancellationToken).SuppressCancellationThrow();
-
-            if (cancelOrFailed)
-            {
-                _assetLoadingList.Remove(assetObjectKey);
-                return null;
-            }
-
-            GameObject gameObject = AssetsReference.Instantiate(handle.AssetObject as GameObject, parent, this).gameObject;
-
-            assetObject = AssetObject.Create(assetObjectKey, handle.AssetObject, handle, this);
-            _assetPool.Register(assetObject, true);
-
-            _assetLoadingList.Remove(assetObjectKey);
-
-            return gameObject;
+            var asset = await GetOrLoadAssetAsync(location, typeof(GameObject), packageName, assetObjectKey, cancellationToken: cancellationToken);
+            return asset != null ? AssetsReference.Instantiate(asset as GameObject, parent, this).gameObject : null;
         }
 
         #endregion
@@ -813,26 +753,12 @@ namespace AlicizaX.Resource.Runtime
 
             string assetObjectKey = GetCacheKey(location, packageName);
 
-            await TryWaitingLoading(assetObjectKey);
-
             float duration = Time.time;
 
-            AssetObject assetObject = _assetPool.Spawn(assetObjectKey);
-            if (assetObject != null)
-            {
-                await UniTask.Yield();
-                loadAssetCallbacks.LoadAssetSuccessCallback(location, assetObject.Target, Time.time - duration, userData);
-                return;
-            }
-
-            _assetLoadingList.Add(assetObjectKey);
-
             AssetInfo assetInfo = GetAssetInfo(location, packageName);
 
             if (!string.IsNullOrEmpty(assetInfo.Error))
             {
-                _assetLoadingList.Remove(assetObjectKey);
-
                 string errorMessage = Utility.Text.Format("Can not load asset '{0}' because :'{1}'.", location, assetInfo.Error);
                 if (loadAssetCallbacks.LoadAssetFailureCallback != null)
                 {
@@ -843,41 +769,23 @@ namespace AlicizaX.Resource.Runtime
                 throw new GameFrameworkException(errorMessage);
             }
 
-            AssetHandle handle = GetHandleAsync(location, assetType, packageName: packageName);
-
-            if (loadAssetCallbacks.LoadAssetUpdateCallback != null)
+            try
             {
-                InvokeProgress(location, handle, loadAssetCallbacks.LoadAssetUpdateCallback, userData).Forget();
+                var asset = await GetOrLoadAssetAsync(location, assetType, packageName, assetObjectKey, NormalizePriority(priority), default,
+                    handle => StartProgressTask(location, handle, loadAssetCallbacks.LoadAssetUpdateCallback, userData));
+                loadAssetCallbacks.LoadAssetSuccessCallback?.Invoke(location, asset, Time.time - duration, userData);
             }
-
-            await handle.ToUniTask();
-
-            if (handle.AssetObject == null || handle.Status == EOperationStatus.Failed)
+            catch (Exception ex)
             {
-                _assetLoadingList.Remove(assetObjectKey);
-
                 string errorMessage = Utility.Text.Format("Can not load asset '{0}'.", location);
+                Log.Error($"{errorMessage} {ex}");
                 if (loadAssetCallbacks.LoadAssetFailureCallback != null)
                 {
                     loadAssetCallbacks.LoadAssetFailureCallback(location, LoadResourceStatus.NotReady, errorMessage, userData);
                     return;
                 }
 
-                throw new GameFrameworkException(errorMessage);
-            }
-            else
-            {
-                assetObject = AssetObject.Create(assetObjectKey, handle.AssetObject, handle, this);
-                _assetPool.Register(assetObject, true);
-
-                _assetLoadingList.Remove(assetObjectKey);
-
-                if (loadAssetCallbacks.LoadAssetSuccessCallback != null)
-                {
-                    duration = Time.time - duration;
-
-                    loadAssetCallbacks.LoadAssetSuccessCallback(location, handle.AssetObject, duration, userData);
-                }
+                throw;
             }
         }
 
@@ -915,26 +823,12 @@ namespace AlicizaX.Resource.Runtime
 
             string assetObjectKey = GetCacheKey(location, packageName);
 
-            await TryWaitingLoading(assetObjectKey);
-
             float duration = Time.time;
 
-            AssetObject assetObject = _assetPool.Spawn(assetObjectKey);
-            if (assetObject != null)
-            {
-                await UniTask.Yield();
-                loadAssetCallbacks.LoadAssetSuccessCallback(location, assetObject.Target, Time.time - duration, userData);
-                return;
-            }
-
-            _assetLoadingList.Add(assetObjectKey);
-
             AssetInfo assetInfo = GetAssetInfo(location, packageName);
 
             if (!string.IsNullOrEmpty(assetInfo.Error))
             {
-                _assetLoadingList.Remove(assetObjectKey);
-
                 string errorMessage = Utility.Text.Format("Can not load asset '{0}' because :'{1}'.", location, assetInfo.Error);
                 if (loadAssetCallbacks.LoadAssetFailureCallback != null)
                 {
@@ -945,41 +839,23 @@ namespace AlicizaX.Resource.Runtime
                 throw new GameFrameworkException(errorMessage);
             }
 
-            AssetHandle handle = GetHandleAsync(location, assetInfo.AssetType, packageName: packageName);
-
-            if (loadAssetCallbacks.LoadAssetUpdateCallback != null)
+            try
             {
-                InvokeProgress(location, handle, loadAssetCallbacks.LoadAssetUpdateCallback, userData).Forget();
+                var asset = await GetOrLoadAssetAsync(location, assetInfo.AssetType, packageName, assetObjectKey, NormalizePriority(priority), default,
+                    handle => StartProgressTask(location, handle, loadAssetCallbacks.LoadAssetUpdateCallback, userData));
+                loadAssetCallbacks.LoadAssetSuccessCallback?.Invoke(location, asset, Time.time - duration, userData);
             }
-
-            await handle.ToUniTask();
-
-            if (handle.AssetObject == null || handle.Status == EOperationStatus.Failed)
+            catch (Exception ex)
             {
-                _assetLoadingList.Remove(assetObjectKey);
-
                 string errorMessage = Utility.Text.Format("Can not load asset '{0}'.", location);
+                Log.Error($"{errorMessage} {ex}");
                 if (loadAssetCallbacks.LoadAssetFailureCallback != null)
                 {
                     loadAssetCallbacks.LoadAssetFailureCallback(location, LoadResourceStatus.NotReady, errorMessage, userData);
                     return;
                 }
 
-                throw new GameFrameworkException(errorMessage);
-            }
-            else
-            {
-                assetObject = AssetObject.Create(assetObjectKey, handle.AssetObject, handle, this);
-                _assetPool.Register(assetObject, true);
-
-                _assetLoadingList.Remove(assetObjectKey);
-
-                if (loadAssetCallbacks.LoadAssetSuccessCallback != null)
-                {
-                    duration = Time.time - duration;
-
-                    loadAssetCallbacks.LoadAssetSuccessCallback(location, handle.AssetObject, duration, userData);
-                }
+                throw;
             }
         }
 
@@ -992,11 +868,21 @@ namespace AlicizaX.Resource.Runtime
 
             if (loadAssetUpdateCallback != null)
             {
+                float lastReportedProgress = -1f;
                 while (assetHandle is { IsValid: true, IsDone: false })
                 {
                     await UniTask.Yield();
+                    float progress = assetHandle.Progress;
+                    if (lastReportedProgress < 0f || progress - lastReportedProgress >= ProgressCallbackThreshold)
+                    {
+                        lastReportedProgress = progress;
+                        loadAssetUpdateCallback.Invoke(location, progress, userData);
+                    }
+                }
 
-                    loadAssetUpdateCallback.Invoke(location, assetHandle.Progress, userData);
+                if (assetHandle is { IsValid: true } && lastReportedProgress < 1f)
+                {
+                    loadAssetUpdateCallback.Invoke(location, 1f, userData);
                 }
             }
         }
@@ -1039,29 +925,114 @@ namespace AlicizaX.Resource.Runtime
 
         #endregion
 
-        private readonly TimeoutController _timeoutController = new TimeoutController();
-
-        private async UniTask TryWaitingLoading(string assetObjectKey)
+        private async UniTask<UnityEngine.Object> GetOrLoadAssetAsync(string location, Type assetType, string packageName,
+            string assetObjectKey, uint priority = 0, CancellationToken cancellationToken = default, Action<AssetHandle> onHandleCreated = null)
         {
-            if (_assetLoadingList.Contains(assetObjectKey))
+            while (true)
             {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                AssetObject cachedAssetObject = _assetPool.Spawn(assetObjectKey);
+                if (cachedAssetObject != null)
+                {
+                    return cachedAssetObject.Target as UnityEngine.Object;
+                }
+
+                if (!TryBeginLoading(assetObjectKey))
+                {
+                    await WaitForLoadingAsync(assetObjectKey, cancellationToken);
+                    continue;
+                }
+
+                AssetHandle handle = null;
                 try
                 {
-                    await UniTask.WaitUntil(() => !_assetLoadingList.Contains(assetObjectKey))
-#if UNITY_EDITOR
-                        .AttachExternalCancellation(_timeoutController.Timeout(TimeSpan.FromSeconds(60)));
-                    _timeoutController.Reset();
-#else
-                    ;
-#endif
-                }
-                catch (OperationCanceledException ex)
-                {
-                    if (_timeoutController.IsTimeout())
+                    handle = GetHandleAsync(location, assetType, packageName: packageName, priority: priority);
+                    onHandleCreated?.Invoke(handle);
+                    await handle.ToUniTask();
+
+                    if (handle.AssetObject == null || handle.Status == EOperationStatus.Failed)
                     {
-                        Log.Error($"LoadAssetAsync Waiting {assetObjectKey} timeout. reason:{ex.Message}");
+                        throw new GameFrameworkException(Utility.Text.Format("Can not load asset '{0}'.", location));
                     }
+
+                    var assetObject = AssetObject.Create(assetObjectKey, handle.AssetObject, handle, this);
+                    _assetPool.Register(assetObject, true);
+                    CompleteLoading(assetObjectKey);
+                    return handle.AssetObject as UnityEngine.Object;
                 }
+                catch (Exception ex)
+                {
+                    DisposeHandle(handle);
+                    FailLoading(assetObjectKey, ex);
+                    throw;
+                }
+            }
+        }
+
+        private bool TryBeginLoading(string assetObjectKey)
+        {
+            if (_assetLoadingOperations.ContainsKey(assetObjectKey))
+            {
+                return false;
+            }
+
+            _assetLoadingOperations.Add(assetObjectKey, new UniTaskCompletionSource<bool>());
+            return true;
+        }
+
+        private async UniTask WaitForLoadingAsync(string assetObjectKey, CancellationToken cancellationToken = default)
+        {
+            if (!_assetLoadingOperations.TryGetValue(assetObjectKey, out var loadingOperation))
+            {
+                return;
+            }
+
+            if (cancellationToken.CanBeCanceled)
+            {
+                await loadingOperation.Task.AttachExternalCancellation(cancellationToken);
+            }
+            else
+            {
+                await loadingOperation.Task;
+            }
+        }
+
+        private void CompleteLoading(string assetObjectKey)
+        {
+            if (!_assetLoadingOperations.TryGetValue(assetObjectKey, out var loadingOperation))
+            {
+                return;
+            }
+
+            _assetLoadingOperations.Remove(assetObjectKey);
+            loadingOperation.TrySetResult(true);
+        }
+
+        private void FailLoading(string assetObjectKey, Exception exception)
+        {
+            if (!_assetLoadingOperations.TryGetValue(assetObjectKey, out var loadingOperation))
+            {
+                return;
+            }
+
+            _assetLoadingOperations.Remove(assetObjectKey);
+            loadingOperation.TrySetException(exception);
+        }
+
+        private void DisposeHandle(AssetHandle handle)
+        {
+            if (handle is { IsValid: true })
+            {
+                handle.Dispose();
+            }
+        }
+
+        private void StartProgressTask(string location, AssetHandle handle, LoadAssetUpdateCallback loadAssetUpdateCallback, object userData)
+        {
+            if (loadAssetUpdateCallback != null && handle is { IsValid: true, IsDone: false })
+            {
+                InvokeProgress(location, handle, loadAssetUpdateCallback, userData).Forget();
             }
         }