// ============================================================================
|
// ResourceCacheManager.cs — 全局资源缓存管理器
|
// Feature: 001-async-resource-loading
|
// ============================================================================
|
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using UnityEngine;
|
using Cysharp.Threading.Tasks;
|
using YooAsset;
|
|
namespace ProjSG.Resource
|
{
|
/// <summary>
|
/// 全局资源缓存管理器。
|
/// 提供同步缓存获取、异步加载+去重、LRU 淘汰等能力。
|
/// </summary>
|
public class ResourceCacheManager : Singleton<ResourceCacheManager>, IResourceCache
|
{
|
/// <summary>
|
/// 缓存条目
|
/// </summary>
|
private class CachedResource
|
{
|
public UnityEngine.Object Asset;
|
public AssetHandle Handle;
|
public bool IsPermanent;
|
public float LastAccessTime;
|
}
|
|
/// <summary>已缓存的资源</summary>
|
private readonly Dictionary<string, CachedResource> _syncCache = new Dictionary<string, CachedResource>();
|
|
/// <summary>正在加载中的任务（用于去重）</summary>
|
private readonly Dictionary<string, UniTask<UnityEngine.Object>> _loadingTasks = new Dictionary<string, UniTask<UnityEngine.Object>>();
|
|
/// <summary>LRU 淘汰阈值（非常驻资源数量超过此值时触发淘汰）</summary>
|
private const int LRU_THRESHOLD = 200;
|
|
/// <summary>淘汰后保留的非常驻资源数量</summary>
|
private const int LRU_KEEP_COUNT = 150;
|
|
/// <inheritdoc/>
|
public int CachedCount => _syncCache.Count;
|
|
// ====================================================================
|
// 同步获取
|
// ====================================================================
|
|
/// <inheritdoc/>
|
public T GetCached<T>(string location) where T : UnityEngine.Object
|
{
|
if (string.IsNullOrEmpty(location)) return null;
|
|
if (_syncCache.TryGetValue(location, out var cached))
|
{
|
cached.LastAccessTime = Time.unscaledTime;
|
return cached.Asset as T;
|
}
|
|
return null;
|
}
|
|
/// <inheritdoc/>
|
public bool IsCached(string location)
|
{
|
return !string.IsNullOrEmpty(location) && _syncCache.ContainsKey(location);
|
}
|
|
// ====================================================================
|
// 异步获取（缓存穿透 + 去重）
|
// ====================================================================
|
|
/// <inheritdoc/>
|
public async UniTask<T> GetOrLoadAsync<T>(string location) where T : UnityEngine.Object
|
{
|
if (string.IsNullOrEmpty(location))
|
{
|
Debug.LogError("ResourceCacheManager.GetOrLoadAsync: location is null or empty");
|
return null;
|
}
|
|
// 1. 缓存命中
|
if (_syncCache.TryGetValue(location, out var cached))
|
{
|
cached.LastAccessTime = Time.unscaledTime;
|
return cached.Asset as T;
|
}
|
|
// 2. 正在加载中 → 等待已有任务（去重）
|
if (_loadingTasks.TryGetValue(location, out var loadingTask))
|
{
|
var result = await loadingTask;
|
return result as T;
|
}
|
|
// 3. 发起新加载
|
var task = LoadAndCacheAsync(location, false);
|
_loadingTasks[location] = task;
|
|
try
|
{
|
var asset = await task;
|
return asset as T;
|
}
|
finally
|
{
|
_loadingTasks.Remove(location);
|
}
|
}
|
|
// ====================================================================
|
// 批量预加载
|
// ====================================================================
|
|
/// <inheritdoc/>
|
public async UniTask PreloadAsync(string[] locations, bool permanent = false, IProgress<float> progress = null)
|
{
|
if (locations == null || locations.Length == 0)
|
{
|
progress?.Report(1f);
|
return;
|
}
|
|
int completed = 0;
|
int total = locations.Length;
|
|
// 过滤已缓存的
|
var toLoad = new List<string>();
|
foreach (var loc in locations)
|
{
|
if (_syncCache.ContainsKey(loc))
|
{
|
// 已缓存，更新常驻标记
|
if (permanent)
|
{
|
_syncCache[loc].IsPermanent = true;
|
}
|
completed++;
|
}
|
else
|
{
|
toLoad.Add(loc);
|
}
|
}
|
|
progress?.Report((float)completed / total);
|
|
// 并行加载（限制并发数）
|
const int maxConcurrency = 8;
|
for (int i = 0; i < toLoad.Count; i += maxConcurrency)
|
{
|
var batch = new List<UniTask>();
|
int batchEnd = Mathf.Min(i + maxConcurrency, toLoad.Count);
|
|
for (int j = i; j < batchEnd; j++)
|
{
|
var loc = toLoad[j];
|
batch.Add(LoadAndCacheAsync(loc, permanent).ContinueWith(_ =>
|
{
|
completed++;
|
progress?.Report((float)completed / total);
|
}));
|
}
|
|
await UniTask.WhenAll(batch);
|
}
|
|
progress?.Report(1f);
|
TryLRUEviction();
|
}
|
|
// ====================================================================
|
// 释放
|
// ====================================================================
|
|
/// <inheritdoc/>
|
public void Release(string location, bool forceRelease = false)
|
{
|
if (string.IsNullOrEmpty(location)) return;
|
|
if (_syncCache.TryGetValue(location, out var cached))
|
{
|
if (cached.IsPermanent && !forceRelease) return;
|
|
if (cached.Handle != null && cached.Handle.IsValid)
|
{
|
cached.Handle.Release();
|
}
|
|
_syncCache.Remove(location);
|
}
|
}
|
|
/// <inheritdoc/>
|
public void ReleaseAll()
|
{
|
var toRemove = new List<string>();
|
|
foreach (var kvp in _syncCache)
|
{
|
if (!kvp.Value.IsPermanent)
|
{
|
if (kvp.Value.Handle != null && kvp.Value.Handle.IsValid)
|
{
|
kvp.Value.Handle.Release();
|
}
|
toRemove.Add(kvp.Key);
|
}
|
}
|
|
foreach (var key in toRemove)
|
{
|
_syncCache.Remove(key);
|
}
|
}
|
|
/// <inheritdoc/>
|
public void ForceReleaseAll()
|
{
|
foreach (var kvp in _syncCache)
|
{
|
if (kvp.Value.Handle != null && kvp.Value.Handle.IsValid)
|
{
|
kvp.Value.Handle.Release();
|
}
|
}
|
|
_syncCache.Clear();
|
_loadingTasks.Clear();
|
}
|
|
// ====================================================================
|
// 内部方法
|
// ====================================================================
|
|
private async UniTask<UnityEngine.Object> LoadAndCacheAsync(string location, bool permanent)
|
{
|
try
|
{
|
var asset = await YooAssetService.Instance.LoadAssetAsync<UnityEngine.Object>(location);
|
|
if (asset != null && !_syncCache.ContainsKey(location))
|
{
|
_syncCache[location] = new CachedResource
|
{
|
Asset = asset,
|
Handle = null, // Handle 由 YooAssetService 管理
|
IsPermanent = permanent,
|
LastAccessTime = Time.unscaledTime,
|
};
|
}
|
|
return asset;
|
}
|
catch (Exception e)
|
{
|
Debug.LogError($"ResourceCacheManager.LoadAndCacheAsync failed for '{location}': {e.Message}");
|
return null;
|
}
|
}
|
|
/// <summary>
|
/// LRU 淘汰：非常驻资源超过阈值时，按访问时间淘汰最旧的资源。
|
/// </summary>
|
private void TryLRUEviction()
|
{
|
var nonPermanent = _syncCache
|
.Where(kvp => !kvp.Value.IsPermanent)
|
.ToList();
|
|
if (nonPermanent.Count <= LRU_THRESHOLD) return;
|
|
// 按访问时间排序，移除最旧的
|
var sorted = nonPermanent
|
.OrderBy(kvp => kvp.Value.LastAccessTime)
|
.ToList();
|
|
int toRemove = sorted.Count - LRU_KEEP_COUNT;
|
for (int i = 0; i < toRemove; i++)
|
{
|
var kvp = sorted[i];
|
if (kvp.Value.Handle != null && kvp.Value.Handle.IsValid)
|
{
|
kvp.Value.Handle.Release();
|
}
|
_syncCache.Remove(kvp.Key);
|
}
|
}
|
}
|
}
|
