【Unity】次时代对象池

发表于 2025-09-03 更新于 2026-05-24

1. 架构设计特点

单例模式与模块化设计

采用单例模式确保全局唯一的对象池管理器
模块化设计，职责分离明确：
- GameObjectPool：主管理器
- ConfigPool：配置组对象池
- PooledObject：池化对象封装
- PrefabRefInfo：预制体引用计数

配置驱动架构

1 2	[CreateAssetMenu(fileName = "PoolConfig", menuName = "GameplaySystem/PoolConfig", order = 10)] public class PoolConfigScriptableObject : ScriptableObject

使用ScriptableObject配置池参数
支持可视化配置管理
配置与代码分离，便于调整

2. 资源管理特点

双重资源加载策略

public interface IResourceLoader
{
    GameObject LoadPrefab(string location);
    UniTask<GameObject> LoadPrefabAsync(string location, CancellationToken cancellationToken = default);
}

支持Unity Resources和TEngine两种资源加载方式
接口抽象，易于扩展其他资源系统
同步/异步加载双重支持

智能引用计数管理

public void AddRef()
{
    RefCount++;
    LastAccessTime = Time.time;
}

public void RemoveRef()
{
    if (RefCount > 0) RefCount--;
}

防止内存泄漏的引用计数机制
时间戳记录，支持过期清理
防重复减少引用计数的保护机制

3. 性能优化特点

对象重用策略

1
2
3

// 重用临时队列，避免重复创建
private static Queue<PooledObject> _tempQueue = new Queue<PooledObject>();
private static readonly List<PooledObject> _expiredObjects = new List<PooledObject>();

静态临时容器重用，减少GC压力
队列交换技术优化内存分配
过期对象批量清理机制

异步加载优化

if (LoadingAssets.Contains(assetPath))
{
    var completionSource = new UniTaskCompletionSource<GameObject>();
    if (!PendingRequests.ContainsKey(assetPath))
    {
        PendingRequests[assetPath] = new List<UniTaskCompletionSource<GameObject>>();
    }
    PendingRequests[assetPath].Add(completionSource);
}

避免重复加载同一资源
挂起请求队列管理
UniTask异步框架支持取消操作

4. 内存管理特点

分层过期清理机制

public void CheckExpiredObjects()
{
    // 清理过期对象
    CheckExpiredPrefabs(); // 清理过期预制体
}

对象级别过期清理
预制体级别过期清理
定时清理避免内存积累

智能池容量管理

if (AllObjects.Count < Config.poolcnt)
{
    // 创建新对象
}
else
{
    // 复用最旧的非活跃对象
    PooledObject oldestObj = null;
    float oldestTime = float.MaxValue;
    foreach (var obj in AllObjects)
    {
        if (!obj.isActive && obj.lastUsedTime < oldestTime)
        {
            oldestTime = obj.lastUsedTime;
            oldestObj = obj;
        }
    }
}

LRU（最近最少使用）策略
动态容量调整
防止池无限增长

5. 监控与调试特点

完善的Editor扩展

1 2	[CustomEditor(typeof(GameObjectPool))] public class GameObjectPoolEditor : UnityEditor.Editor

实时监控池状态
可视化进度条显示使用率
详细的对象生命周期信息
自动刷新机制

丰富的状态信息

public class PoolObjectInfo
{
    public float remainingTime;
    public float expireProgress;
    public bool isActive;
}

过期进度可视化
剩余时间显示
活跃状态监控

6. 错误处理特点

防御性编程

public void RemoveRef()
{
    if (RefCount > 0)
    {
        RefCount--;
    }
    else
    {
        Log.Warning($"尝试减少已经为0的引用计数: {AssetPath}");
    }
}

引用计数边界检查
空引用检查
重复操作保护

异常恢复机制

while (AvailableObjects.Count > 0)
{
    var obj = AvailableObjects.Dequeue();
    if (obj.gameObject == null)
    {
        // 处理已销毁对象
        continue;
    }
}

自动清理无效对象
队列一致性维护
异常状态恢复

7. 扩展性特点

接口设计

IResourceLoader接口支持多种资源系统
配置驱动支持运行时调整
事件回调机制支持自定义逻辑

生命周期管理

public class PoolObjectMonitor : MonoBehaviour
{
    private void OnDestroy()
    {
        if (_pool != null && _pooledObject != null)
        {
            _pool.OnObjectDestroyed(_pooledObject);
        }
    }
}

自动生命周期监控
销毁事件处理
状态同步机制

8. 使用便利性特点

简化的API设计

public static class GameObjectPoolHelper
{
    public static GameObject LoadGameObject(string assetPath);
    public static async UniTask<GameObject> LoadGameObjectAsync(string assetPath, CancellationToken cancellationToken = default);
}

静态辅助类简化调用
同步/异步双重接口
取消令牌支持

总结

这个对象池系统展现了以下核心优势：

高性能：通过对象重用、静态容器复用、批量清理等手段最小化GC压力
高可靠性：完善的错误处理、防御性编程、状态一致性保证
高可维护性：模块化设计、配置驱动、丰富的调试信息
高扩展性：接口抽象、事件机制、生命周期管理
易用性：简化的API、详细的文档、可视化配置

整体而言，这是一个企业级的对象池实现，适用于对性能和稳定性要求较高的游戏项目。

#region Class Documentation

/************************************************************************************************************
Class Name:     GameObjectPool.cs
Type:           Pool, GameObject, GameObjectPool

Example:
                // 异步加载游戏物体。
                var gameObject = await GameObjectPool.Instance.GetGameObjectAsync(path, token);

                // 同步加载游戏物体。
                var gameObject = GameObjectPool.Instance.GetGameObject(path);

Example1:
                // 异步加载游戏物体。
                var gameObject = await GameObjectPoolHelper.LoadGameObjectAsync(path, token);

                // 同步加载游戏物体。
                var gameObject = GameObjectPoolHelper.LoadGameObject(path);
************************************************************************************************************/

#endregion

using System;
using System.Collections.Generic;
using System.Threading;
using Cysharp.Threading.Tasks;
using UnityEngine;
using TEngine;

#if UNITY_EDITOR
using UnityEditor;
#endif

namespace GameplaySystem
{
    [CreateAssetMenu(fileName = "PoolConfig", menuName = "GameplaySystem/PoolConfig", order = 10)]
    public class PoolConfigScriptableObject : ScriptableObject
    {
        public List<PoolConfig> configs;
    }

    /// <summary>
    /// 对象池配置项。
    /// </summary>
    [Serializable]
    public class PoolConfig
    {
        public string asset;
        public float time;
        public int poolcnt;
    }
    
    /// <summary>
    /// 预制体引用计数信息。
    /// </summary>
    public class PrefabRefInfo
    {
        public GameObject Prefab;
        public int RefCount;
        public float LastAccessTime;
        public string AssetPath;
    
        public PrefabRefInfo(GameObject prefab, string assetPath)
        {
            this.Prefab = prefab;
            this.AssetPath = assetPath;
            this.RefCount = 0;
            this.LastAccessTime = Time.time;
        }
    
        public void AddRef()
        {
            RefCount++;
            LastAccessTime = Time.time;
        }
    
        public void RemoveRef()
        {
            if (RefCount > 0) // 防止引用计数变成负数
            {
                RefCount--;
                if (RefCount > 0)
                {
                    LastAccessTime = Time.time;
                }
                Log.Debug($"RemoveRef: {AssetPath}, refCount: {RefCount}");
            }
            else
            {
                Log.Warning($"尝试减少已经为0的引用计数: {AssetPath}");
            }
        }
    
        public bool CanUnload(float expireTime)
        {
            return RefCount <= 0 && expireTime > 0 && (Time.time - LastAccessTime) > expireTime;
        }
    }
    
    [Serializable]
    public class PooledObject
    {
        public GameObject gameObject;
        public string assetPath;
        public float lastUsedTime;
        public bool isActive;
        public string instanceName;
        public bool isRefCountReduced;
    
        public PooledObject(GameObject go, string path)
        {
            gameObject = go;
            assetPath = path;
            lastUsedTime = Time.time;
            isActive = false;
            instanceName = go.name;
            isRefCountReduced = false;
        }
    
        /// <summary>
        /// 获取过期进度 (0-1)，1表示即将过期。
        /// </summary>
        public float GetExpireProgress(float expireTime)
        {
            if (expireTime <= 0 || isActive) return 0f;
            float timeElapsed = Time.time - lastUsedTime;
            return Mathf.Clamp01(timeElapsed / expireTime);
        }
    
        /// <summary>
        /// 获取剩余时间。
        /// </summary>
        public float GetRemainingTime(float expireTime)
        {
            if (expireTime <= 0 || isActive) return -1f;
            float timeElapsed = Time.time - lastUsedTime;
            return Mathf.Max(0f, expireTime - timeElapsed);
        }
    }
    
    /// <summary>
    /// Inspector显示用的对象信息。
    /// </summary>
    [Serializable]
    public class PoolObjectInfo
    {
        [SerializeField] public string objectName;
        [SerializeField] public string assetPath;
        [SerializeField] public bool isActive;
        [SerializeField] public float lastUsedTime;
        [SerializeField] public float remainingTime;
        [SerializeField] public float expireProgress;
        [SerializeField] public GameObject gameObject;
    
        public void UpdateFromPooledObject(PooledObject pooledObj, float expireTime)
        {
            objectName = pooledObj.instanceName;
            assetPath = pooledObj.assetPath;
            isActive = pooledObj.isActive;
            lastUsedTime = pooledObj.lastUsedTime;
            remainingTime = pooledObj.GetRemainingTime(expireTime);
            expireProgress = pooledObj.GetExpireProgress(expireTime);
            gameObject = pooledObj.gameObject;
        }
    }
    
    /// <summary>
    /// Inspector显示用的预制体信息.
    /// </summary>
    [Serializable]
    public class PrefabRefInfoDisplay
    {
        [SerializeField] public string assetPath;
        [SerializeField] public int refCount;
        [SerializeField] public float lastAccessTime;
        [SerializeField] public GameObject prefab;
    
        public void UpdateFromPrefabRefInfo(PrefabRefInfo info)
        {
            assetPath = info.AssetPath;
            refCount = info.RefCount;
            lastAccessTime = info.LastAccessTime;
            prefab = info.Prefab;
        }
    }
    
    /// <summary>
    /// Inspector显示用的池信息。
    /// </summary>
    [Serializable]
    public class ConfigPoolInfo
    {
        [SerializeField] public string configAsset;
        [SerializeField] public int maxCount;
        [SerializeField] public float expireTime;
        [SerializeField] public int totalObjects;
        [SerializeField] public int activeObjects;
        [SerializeField] public int availableObjects;
        [SerializeField] public int loadedPrefabs;
        [SerializeField] public List<string> assetPaths = new List<string>();
        [SerializeField] public List<PoolObjectInfo> objects = new List<PoolObjectInfo>();
        [SerializeField] public List<PrefabRefInfoDisplay> prefabRefs = new List<PrefabRefInfoDisplay>();
    
        public void UpdateFromPool(ConfigPool pool)
        {
            configAsset = pool.Config.asset;
            maxCount = pool.Config.poolcnt;
            expireTime = pool.Config.time;
            totalObjects = pool.AllObjects.Count;
    
            activeObjects = 0;
            foreach (var obj in pool.AllObjects)
            {
                if (obj.isActive) activeObjects++;
            }
    
            availableObjects = pool.AvailableObjects.Count;
            loadedPrefabs = pool.LoadedPrefabs.Count;
    
            assetPaths.Clear();
            assetPaths.AddRange(pool.LoadedPrefabs.Keys);
    
            objects.Clear();
            int objectIndex = 0;
            foreach (var pooledObj in pool.AllObjects)
            {
                if (pooledObj.gameObject != null)
                {
                    PoolObjectInfo info;
                    if (objectIndex < objects.Count)
                    {
                        info = objects[objectIndex];
                    }
                    else
                    {
                        info = new PoolObjectInfo();
                        objects.Add(info);
                    }
    
                    info.UpdateFromPooledObject(pooledObj, pool.Config.time);
                    objectIndex++;
                }
            }
    
            prefabRefs.Clear();
            int prefabIndex = 0;
            foreach (var kvp in pool.LoadedPrefabs)
            {
                PrefabRefInfoDisplay info;
                if (prefabIndex < prefabRefs.Count)
                {
                    info = prefabRefs[prefabIndex];
                }
                else
                {
                    info = new PrefabRefInfoDisplay();
                    prefabRefs.Add(info);
                }
    
                info.UpdateFromPrefabRefInfo(kvp.Value);
                prefabIndex++;
            }
        }
    }
    
    /// <summary>
    /// 配置组对象池 - 管理一个PoolConfig下的所有资源。
    /// </summary>
    public class ConfigPool
    {
        public readonly PoolConfig Config;
        public Queue<PooledObject> AvailableObjects;
        public readonly HashSet<PooledObject> AllObjects;
        public readonly Dictionary<string, PrefabRefInfo> LoadedPrefabs;
        public readonly Dictionary<string, List<UniTaskCompletionSource<GameObject>>> PendingRequests;
        public readonly HashSet<string> LoadingAssets;
        public readonly Transform PoolRoot;
    
        private readonly IResourceLoader _resourceLoader;
    
        // 重用临时队列，避免重复创建。
        private static Queue<PooledObject> _tempQueue = new Queue<PooledObject>();
    
        // 重用过期对象列表，避免重复创建。
        private static readonly List<PooledObject> _expiredObjects = new List<PooledObject>();
        private static readonly List<string> _expiredPrefabs = new List<string>();
    
        public ConfigPool(PoolConfig config, IResourceLoader resourceLoader)
        {
            _resourceLoader = resourceLoader;
            Config = config;
            AvailableObjects = new Queue<PooledObject>();
            AllObjects = new HashSet<PooledObject>();
            LoadedPrefabs = new Dictionary<string, PrefabRefInfo>();
            PendingRequests = new Dictionary<string, List<UniTaskCompletionSource<GameObject>>>();
            LoadingAssets = new HashSet<string>();
    
            // 创建池根节点。
            GameObject poolRootGo = new GameObject($"ConfigPool_{config.asset.Replace('/', '_')}");
            PoolRoot = poolRootGo.transform;
            PoolRoot.SetParent(GameObjectPool.Instance.poolContainer);
            poolRootGo.SetActive(false);
        }
    
        public bool MatchesAsset(string assetPath)
        {
            return assetPath.StartsWith(Config.asset);
        }
    
        /// <summary>
        /// 同步获取对象，如果资源未加载则同步加载。
        /// </summary>
        public GameObject Get(string assetPath)
        {
            if (!LoadedPrefabs.ContainsKey(assetPath))
            {
                if (LoadingAssets.Contains(assetPath))
                {
                    Log.Warning($"资源 {assetPath} 正在异步加载中，同步获取可能导致重复加载，建议使用异步方法");
                }
    
                try
                {
                    GameObject prefab = _resourceLoader.LoadPrefab(assetPath);
                    if (prefab != null)
                    {
                        LoadedPrefabs[assetPath] = new PrefabRefInfo(prefab, assetPath);
                        Log.Debug($"同步加载资源成功: {assetPath}");
                    }
                    else
                    {
                        Log.Error($"同步加载资源失败: {assetPath}");
                        return null;
                    }
                }
                catch (Exception e)
                {
                    Log.Error($"同步加载资源异常: {assetPath}, 错误: {e.Message}");
                    return null;
                }
            }
    
            return GetInternal(assetPath);
        }
    
        /// <summary>
        /// 异步获取对象。
        /// </summary>
        public async UniTask<GameObject> GetAsync(string assetPath, CancellationToken cancellationToken = default)
        {
            if (LoadedPrefabs.ContainsKey(assetPath))
            {
                return GetInternal(assetPath);
            }
    
            if (LoadingAssets.Contains(assetPath))
            {
                var completionSource = new UniTaskCompletionSource<GameObject>();
                if (!PendingRequests.ContainsKey(assetPath))
                {
                    PendingRequests[assetPath] = new List<UniTaskCompletionSource<GameObject>>();
                }
    
                PendingRequests[assetPath].Add(completionSource);
    
                try
                {
                    return await completionSource.Task.AttachExternalCancellation(cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    PendingRequests[assetPath].Remove(completionSource);
                    throw;
                }
            }
    
            LoadingAssets.Add(assetPath);
            try
            {
                GameObject prefab = await _resourceLoader.LoadPrefabAsync(assetPath, cancellationToken);
                if (prefab != null)
                {
                    LoadedPrefabs[assetPath] = new PrefabRefInfo(prefab, assetPath);
                    Log.Debug($"异步加载资源成功: {assetPath}");
    
                    if (PendingRequests.ContainsKey(assetPath))
                    {
                        var requests = PendingRequests[assetPath];
                        PendingRequests.Remove(assetPath);
    
                        foreach (var request in requests)
                        {
                            try
                            {
                                var go = GetInternal(assetPath);
                                request.TrySetResult(go);
                            }
                            catch (Exception e)
                            {
                                request.TrySetException(e);
                            }
                        }
                    }
    
                    return GetInternal(assetPath);
                }
                else
                {
                    throw new Exception($"无法异步加载资源: {assetPath}");
                }
            }
            catch (Exception e)
            {
                Log.Error($"异步加载资源失败: {assetPath}, 错误: {e.Message}");
    
                if (PendingRequests.ContainsKey(assetPath))
                {
                    var requests = PendingRequests[assetPath];
                    PendingRequests.Remove(assetPath);
    
                    foreach (var request in requests)
                    {
                        request.TrySetException(e);
                    }
                }
    
                throw;
            }
            finally
            {
                LoadingAssets.Remove(assetPath);
            }
        }
    
        private GameObject GetInternal(string assetPath)
        {
            PooledObject pooledObj = null;
    
            _tempQueue.Clear();
    
            while (AvailableObjects.Count > 0)
            {
                var obj = AvailableObjects.Dequeue();
                if (obj.gameObject == null)
                {
                    // 只有在引用计数未减少时才处理
                    if (!obj.isRefCountReduced)
                    {
                        OnObjectReallyDestroyed(obj);
                    }
                    else
                    {
                        // 只需要从集合中移除，不需要减少引用计数
                        AllObjects.Remove(obj);
                    }
    
                    continue;
                }
    
                if (obj.assetPath == assetPath)
                {
                    pooledObj = obj;
                    break;
                }
                else
                {
                    _tempQueue.Enqueue(obj);
                }
            }
    
            // 将不匹配的对象放回队列
            while (_tempQueue.Count > 0)
            {
                AvailableObjects.Enqueue(_tempQueue.Dequeue());
            }
    
            if (pooledObj == null)
            {
                if (AllObjects.Count < Config.poolcnt)
                {
                    var prefabRefInfo = LoadedPrefabs[assetPath];
                    GameObject instantiate = GameObject.Instantiate(prefabRefInfo.Prefab);
                    pooledObj = new PooledObject(instantiate, assetPath);
                    AllObjects.Add(pooledObj);
    
                    prefabRefInfo.AddRef();
    
                    var monitor = instantiate.GetComponent<PoolObjectMonitor>();
                    if (monitor == null)
                    {
                        monitor = instantiate.AddComponent<PoolObjectMonitor>();
                    }
    
                    monitor.Initialize(this, pooledObj);
                }
                else
                {
                    PooledObject oldestObj = null;
                    float oldestTime = float.MaxValue;
    
                    foreach (var obj in AllObjects)
                    {
                        if (!obj.isActive && obj.lastUsedTime < oldestTime)
                        {
                            oldestTime = obj.lastUsedTime;
                            oldestObj = obj;
                        }
                    }
    
                    if (oldestObj != null)
                    {
                        DestroyPooledObject(oldestObj);
    
                        var prefabRefInfo = LoadedPrefabs[assetPath];
                        GameObject instantiate = GameObject.Instantiate(prefabRefInfo.Prefab);
                        pooledObj = new PooledObject(instantiate, assetPath);
                        AllObjects.Add(pooledObj);
    
                        prefabRefInfo.AddRef();
    
                        var monitor = instantiate.GetComponent<PoolObjectMonitor>();
                        if (monitor == null)
                        {
                            monitor = instantiate.AddComponent<PoolObjectMonitor>();
                        }
    
                        monitor.Initialize(this, pooledObj);
                    }
                    else
                    {
                        Log.Warning($"对象池已满且所有对象都在使用中: {Config.asset}，无法创建新对象 {assetPath}");
                        return null;
                    }
                }
            }
    
            pooledObj.isActive = true;
            pooledObj.lastUsedTime = Time.time;
            pooledObj.gameObject.SetActive(true);
            pooledObj.gameObject.transform.SetParent(null);
    
            return pooledObj.gameObject;
        }
    
        public void Return(GameObject go)
        {
            PooledObject pooledObj = null;
            foreach (var obj in AllObjects)
            {
                if (obj.gameObject == go)
                {
                    pooledObj = obj;
                    break;
                }
            }
    
            if (pooledObj != null && pooledObj.isActive)
            {
                pooledObj.isActive = false;
                pooledObj.lastUsedTime = Time.time;
    
                go.SetActive(false);
                go.transform.SetParent(PoolRoot);
                go.transform.localPosition = Vector3.zero;
                go.transform.localRotation = Quaternion.identity;
                go.transform.localScale = Vector3.one;
    
                AvailableObjects.Enqueue(pooledObj);
            }
        }
    
        public void OnObjectDestroyed(PooledObject pooledObj)
        {
            // 防止重复减少引用计数
            if (!pooledObj.isRefCountReduced)
            {
                OnObjectReallyDestroyed(pooledObj);
            }
            else
            {
                // 只需要从集合中移除
                AllObjects.Remove(pooledObj);
                CleanAvailableQueue(pooledObj);
            }
        }
    
        private void OnObjectReallyDestroyed(PooledObject pooledObj)
        {
            // 标记引用计数已减少，防止重复处理
            if (pooledObj.isRefCountReduced)
            {
                return;
            }
    
            pooledObj.isRefCountReduced = true;
            AllObjects.Remove(pooledObj);
    
            // 减少预制体引用计数
            if (LoadedPrefabs.TryGetValue(pooledObj.assetPath, out PrefabRefInfo refInfo))
            {
                refInfo.RemoveRef();
            }
    
            CleanAvailableQueue(pooledObj);
        }
    
        // 清理可用队列
        private void CleanAvailableQueue(PooledObject pooledObj)
        {
            _tempQueue.Clear();
            while (AvailableObjects.Count > 0)
            {
                var obj = AvailableObjects.Dequeue();
                if (obj != pooledObj)
                {
                    _tempQueue.Enqueue(obj);
                }
            }
    
            // 交换队列
            (AvailableObjects, _tempQueue) = (_tempQueue, AvailableObjects);
        }
    
        private void DestroyPooledObject(PooledObject pooledObj)
        {
            // 先标记引用计数已减少
            if (pooledObj.isRefCountReduced)
            {
                return;
            }
    
            // 先处理引用计数
            OnObjectReallyDestroyed(pooledObj);
    
            if (pooledObj.gameObject != null)
            {
                GameObject.Destroy(pooledObj.gameObject);
            }
        }
    
        public void CheckExpiredObjects()
        {
            if (Config.time <= 0) return;
    
            float currentTime = Time.time;
    
            // 重用过期对象列表
            _expiredObjects.Clear();
    
            foreach (var obj in AllObjects)
            {
                if (!obj.isActive && !obj.isRefCountReduced && (currentTime - obj.lastUsedTime) > Config.time)
                {
                    _expiredObjects.Add(obj);
                }
            }
    
            foreach (var expiredObj in _expiredObjects)
            {
                DestroyPooledObject(expiredObj);
            }
    
            // 重建可用队列
            _tempQueue.Clear();
            while (AvailableObjects.Count > 0)
            {
                var obj = AvailableObjects.Dequeue();
                if (AllObjects.Contains(obj) && !obj.isRefCountReduced)
                {
                    _tempQueue.Enqueue(obj);
                }
            }
    
            // 交换队列
            (AvailableObjects, _tempQueue) = (_tempQueue, AvailableObjects);
    
            CheckExpiredPrefabs();
        }
    
        private void CheckExpiredPrefabs()
        {
            if (Config.time <= 0) return;
    
            // 重用过期预制体列表
            _expiredPrefabs.Clear();
    
            foreach (var kvp in LoadedPrefabs)
            {
                var refInfo = kvp.Value;
                if (refInfo.CanUnload(Config.time))
                {
                    _expiredPrefabs.Add(kvp.Key);
                }
            }
    
            foreach (var assetPath in _expiredPrefabs)
            {
                var refInfo = LoadedPrefabs[assetPath];
                Log.Debug($"卸载过期预制体: {assetPath}, 引用计数: {refInfo.RefCount}");
    
                _resourceLoader.UnloadAsset(refInfo.Prefab);
                LoadedPrefabs.Remove(assetPath);
            }
        }
    
        public void Clear()
        {
            foreach (var obj in AllObjects)
            {
                if (obj.gameObject != null)
                {
                    GameObject.Destroy(obj.gameObject);
                }
            }
    
            AllObjects.Clear();
            AvailableObjects.Clear();
    
            foreach (var kvp in LoadedPrefabs)
            {
                var refInfo = kvp.Value;
                if (refInfo.Prefab != null)
                {
                    Log.Debug($"清理时卸载预制体: {kvp.Key}, 引用计数: {refInfo.RefCount}");
                    _resourceLoader.UnloadAsset(refInfo.Prefab);
                }
            }
    
            LoadedPrefabs.Clear();
            LoadingAssets.Clear();
    
            foreach (var requests in PendingRequests.Values)
            {
                foreach (var request in requests)
                {
                    request.TrySetCanceled();
                }
            }
    
            PendingRequests.Clear();
    
            if (PoolRoot != null)
            {
                GameObject.Destroy(PoolRoot.gameObject);
            }
        }
    }
    
    /// <summary>
    /// 对象销毁监听器。
    /// </summary>
    public class PoolObjectMonitor : MonoBehaviour
    {
        private ConfigPool _pool;
        private PooledObject _pooledObject;
    
        public void Initialize(ConfigPool pool, PooledObject pooledObject)
        {
            _pool = pool;
            _pooledObject = pooledObject;
        }
    
        private void OnDestroy()
        {
            if (_pool != null && _pooledObject != null)
            {
                _pool.OnObjectDestroyed(_pooledObject);
            }
        }
    }
    
    /// <summary>
    /// 游戏对象池管理器。
    /// </summary>
    public class GameObjectPool : MonoBehaviour
    {
        private static GameObjectPool _instance;
    
        public static GameObjectPool Instance
        {
            get
            {
                if (_instance == null)
                {
                    GameObject go = new GameObject("[GameObjectPool]");
                    _instance = go.AddComponent<GameObjectPool>();
                    DontDestroyOnLoad(go);
                }
    
                return _instance;
            }
        }
    
        [Header("检查间隔")] public float checkInterval = 10f;
    
        [Header("资源加载器")] public bool useEngineResourceLoader = true;
    
        [Header("Inspector显示设置")] public bool showDetailedInfo = true;
    
        [Header("池状态信息")] [SerializeField] private List<ConfigPoolInfo> poolInfos = new List<ConfigPoolInfo>();
    
        public Transform poolContainer;
        internal IResourceLoader _resourceLoader;
    
        private List<PoolConfig> _poolConfigs;
        private List<ConfigPool> _configPools;
        private Dictionary<GameObject, ConfigPool> _gameObjectToPool;
    
        // 重用预加载对象列表
        private static readonly List<GameObject> _preloadedObjects = new List<GameObject>();
    
        private float _lastCleanupTime;
    
        private void Awake()
        {
            if (_instance == null)
            {
                _instance = this;
                DontDestroyOnLoad(gameObject);
                Initialize();
            }
            else if (_instance != this)
            {
                Destroy(gameObject);
            }
        }
    
        private void Initialize()
        {
            _resourceLoader = useEngineResourceLoader ? new TEngineResourceLoader() as IResourceLoader : new DefaultResourceLoader() as IResourceLoader;
    
            GameObject containerGo = new GameObject("PoolContainer");
            poolContainer = containerGo.transform;
            poolContainer.SetParent(transform);
    
            _configPools = new List<ConfigPool>();
            _gameObjectToPool = new Dictionary<GameObject, ConfigPool>();
    
            try
            {
                _poolConfigs = ModuleSystem.GetModule<IResourceModule>().LoadAsset<PoolConfigScriptableObject>("PoolConfig").configs;
                _poolConfigs.Sort((a, b) => b.asset.Length.CompareTo(a.asset.Length));
    
                foreach (var config in _poolConfigs)
                {
                    var configPool = new ConfigPool(config, _resourceLoader);
                    _configPools.Add(configPool);
                }
            }
            catch (Exception e)
            {
                Log.Error($"加载对象池配置失败: {e.Message}");
                _poolConfigs = new List<PoolConfig>();
            }
    
            // 初始化清理时间
            _lastCleanupTime = Time.time;
        }
    
        private void Update()
        {
            if (Time.time - _lastCleanupTime >= checkInterval)
            {
                PerformCleanup();
                _lastCleanupTime = Time.time;
            }
        }
    
        /// <summary>
        /// 执行对象池清理。
        /// </summary>
        private void PerformCleanup()
        {
            if (_configPools == null || _configPools.Count == 0)
            {
                return;
            }
    
            foreach (var pool in _configPools)
            {
                pool.CheckExpiredObjects();
            }
        }
    
        /// <summary>
        /// 手动触发一次清理。
        /// </summary>
        public void ForceCleanup()
        {
            PerformCleanup();
            _lastCleanupTime = Time.time;
        }
    
        // Editor专用的刷新。
        private void UpdateInspectorInfo()
        {
            poolInfos.Clear();
            foreach (var pool in _configPools)
            {
                var info = new ConfigPoolInfo();
                info.UpdateFromPool(pool);
                poolInfos.Add(info);
            }
        }
    
        public void SetResourceLoader(IResourceLoader resourceLoader)
        {
            _resourceLoader = resourceLoader;
        }
    
        public GameObject GetGameObject(string assetPath)
        {
            ConfigPool pool = FindConfigPool(assetPath);
            GameObject go = null;
    
            if (pool != null)
            {
                go = pool.Get(assetPath);
            }
            else
            {
                go = _resourceLoader.LoadGameObject(assetPath);
            }
    
            if (go != null && pool != null)
            {
                _gameObjectToPool[go] = pool;
            }
    
            return go;
        }
    
        public async UniTask<GameObject> GetGameObjectAsync(string assetPath, CancellationToken cancellationToken = default)
        {
            ConfigPool pool = FindConfigPool(assetPath);
            GameObject go = null;
    
            if (pool != null)
            {
                go = await pool.GetAsync(assetPath, cancellationToken);
            }
            else
            {
                go = await _resourceLoader.LoadGameObjectAsync(assetPath, null, cancellationToken);
            }
    
            if (go != null && pool != null)
            {
                _gameObjectToPool[go] = pool;
            }
    
            return go;
        }
    
        public void Release(GameObject go)
        {
            if (go == null) return;
    
            if (_gameObjectToPool.TryGetValue(go, out ConfigPool pool))
            {
                pool.Return(go);
                _gameObjectToPool.Remove(go);
            }
            else
            {
                Destroy(go);
            }
        }
    
        public async UniTask PreloadAsync(string assetPath, int count = 1, CancellationToken cancellationToken = default)
        {
            ConfigPool pool = FindConfigPool(assetPath);
            if (pool == null)
            {
                Log.Warning($"资源 {assetPath} 没有对应的池配置，无法预加载");
                return;
            }
    
            // 优化：重用预加载对象列表
            _preloadedObjects.Clear();
            for (int i = 0; i < count; i++)
            {
                GameObject go = await pool.GetAsync(assetPath, cancellationToken);
                if (go != null)
                {
                    _preloadedObjects.Add(go);
                }
            }
    
            foreach (var go in _preloadedObjects)
            {
                pool.Return(go);
                _gameObjectToPool.Remove(go);
            }
        }
    
        public void Preload(string assetPath, int count = 1)
        {
            ConfigPool pool = FindConfigPool(assetPath);
            if (pool == null)
            {
                Log.Warning($"资源 {assetPath} 没有对应的池配置，无法预加载");
                return;
            }
    
            // 优化：重用预加载对象列表
            _preloadedObjects.Clear();
            for (int i = 0; i < count; i++)
            {
                GameObject go = pool.Get(assetPath);
                if (go != null)
                {
                    _preloadedObjects.Add(go);
                }
            }
    
            foreach (var go in _preloadedObjects)
            {
                pool.Return(go);
                _gameObjectToPool.Remove(go);
            }
        }
    
        private ConfigPool FindConfigPool(string assetPath)
        {
            foreach (var pool in _configPools)
            {
                if (pool.MatchesAsset(assetPath))
                {
                    return pool;
                }
            }
    
            return null;
        }
    
        /// <summary>
        /// 手动刷新Inspector信息
        /// </summary>
        public void RefreshInspectorInfo()
        {
            UpdateInspectorInfo();
        }
    
        public void ClearAllPools()
        {
            foreach (var pool in _configPools)
            {
                pool.Clear();
            }
    
            _gameObjectToPool.Clear();
            poolInfos.Clear();
        }
    
        private void OnDestroy()
        {
            ClearAllPools();
        }
    }
    
    public interface IResourceLoader
    {
        GameObject LoadPrefab(string location);
        UniTask<GameObject> LoadPrefabAsync(string location, CancellationToken cancellationToken = default);
        GameObject LoadGameObject(string location, Transform parent = null);
        UniTask<GameObject> LoadGameObjectAsync(string location, Transform parent = null, CancellationToken cancellationToken = default);
        void UnloadAsset(GameObject gameObject);
    }
    
    public class DefaultResourceLoader : IResourceLoader
    {
        public GameObject LoadPrefab(string location)
        {
            return Resources.Load<GameObject>(location);
        }
    
        public async UniTask<GameObject> LoadPrefabAsync(string location, CancellationToken cancellationToken = default)
        {
            return await Resources.LoadAsync<GameObject>(location).ToUniTask(cancellationToken: cancellationToken) as GameObject;
        }
    
        public GameObject LoadGameObject(string location, Transform parent = null)
        {
            var prefab = Resources.Load<GameObject>(location);
            if (prefab == null) return null;
    
            var instance = GameObject.Instantiate(prefab);
            if (instance != null && parent != null)
            {
                instance.transform.SetParent(parent);
            }
    
            return instance;
        }
    
        public async UniTask<GameObject> LoadGameObjectAsync(string location, Transform parent = null, CancellationToken cancellationToken = default)
        {
            var prefab = await Resources.LoadAsync<GameObject>(location).ToUniTask(cancellationToken: cancellationToken) as GameObject;
            if (prefab == null) return null;
    
            var instance = GameObject.Instantiate(prefab);
            if (instance != null && parent != null)
            {
                instance.transform.SetParent(parent);
            }
    
            return instance;
        }
    
        public void UnloadAsset(GameObject gameObject)
        {
            Resources.UnloadAsset(gameObject);
        }
    }
    
    public class TEngineResourceLoader : IResourceLoader
    {
        private IResourceModule _resourceModule;
    
        private void CheckInit()
        {
            if (_resourceModule == null)
            {
                _resourceModule = ModuleSystem.GetModule<IResourceModule>();
            }
        }
    
        public GameObject LoadPrefab(string location)
        {
            CheckInit();
            return _resourceModule.LoadAsset<GameObject>(location);
        }
    
        public async UniTask<GameObject> LoadPrefabAsync(string location, CancellationToken cancellationToken = default)
        {
            CheckInit();
            return await _resourceModule.LoadAssetAsync<GameObject>(location, cancellationToken);
        }
    
        public GameObject LoadGameObject(string location, Transform parent = null)
        {
            CheckInit();
            return _resourceModule.LoadGameObject(location, parent);
        }
    
        public async UniTask<GameObject> LoadGameObjectAsync(string location, Transform parent = null, CancellationToken cancellationToken = default)
        {
            CheckInit();
            return await _resourceModule.LoadGameObjectAsync(location, parent, cancellationToken);
        }
    
        public void UnloadAsset(GameObject gameObject)
        {
            CheckInit();
            _resourceModule.UnloadAsset(gameObject);
        }
    }
    
    public static class GameObjectPoolHelper
    {
        public static GameObject LoadGameObject(string assetPath)
        {
            return GameObjectPool.Instance.GetGameObject(assetPath);
        }
    
        public static async UniTask<GameObject> LoadGameObjectAsync(string assetPath, CancellationToken cancellationToken = default)
        {
            return await GameObjectPool.Instance.GetGameObjectAsync(assetPath, cancellationToken);
        }
    
        public static void Release(GameObject go)
        {
            GameObjectPool.Instance.Release(go);
        }
    }
}

#if UNITY_EDITOR
namespace GameplaySystem
{
    [CustomEditor(typeof(GameObjectPool))]
    public class GameObjectPoolEditor : UnityEditor.Editor
    {
        private bool[] _poolFoldouts;
        private bool[] _prefabFoldouts;
        private float _lastRefreshTime;
        private const float AUTO_REFRESH_INTERVAL = 0.1f;

        // 缓存序列化属性，避免重复查找
        private SerializedProperty _poolInfosProperty;
    
        private void OnEnable()
        {
            _poolInfosProperty = serializedObject.FindProperty("poolInfos");
            _lastRefreshTime = Time.time;
        }
    
        public override void OnInspectorGUI()
        {
            var pool = (GameObjectPool)target;
    
            // 更新序列化对象
            serializedObject.Update();
    
            // 绘制默认Inspector
            DrawDefaultInspector();
            EditorGUILayout.Space();
    
            // 手动刷新按钮
            if (GUILayout.Button("刷新池状态信息"))
            {
                RefreshPoolInfo(pool);
            }
    
            // 检查是否需要自动刷新
            bool shouldAutoRefresh = pool.showDetailedInfo &&
                                     Selection.activeGameObject == pool.gameObject &&
                                     Time.time - _lastRefreshTime > AUTO_REFRESH_INTERVAL;
    
            if (shouldAutoRefresh)
            {
                RefreshPoolInfo(pool);
            }
    
            if (!pool.showDetailedInfo)
            {
                serializedObject.ApplyModifiedProperties();
                return;
            }
    
            EditorGUILayout.Space();
            EditorGUILayout.LabelField("对象池详细信息", EditorStyles.boldLabel);
    
            // 重新获取属性以确保数据是最新的
            _poolInfosProperty = serializedObject.FindProperty("poolInfos");
    
            if (_poolInfosProperty != null && _poolInfosProperty.arraySize > 0)
            {
                DrawPoolInfos();
            }
            else
            {
                EditorGUILayout.HelpBox("暂无池信息，请等待系统初始化或点击刷新按钮", MessageType.Info);
            }
    
            // 显示自动刷新状态
            if (Selection.activeGameObject == pool.gameObject)
            {
                EditorGUILayout.HelpBox("Inspector正在自动刷新 (仅在选中时)", MessageType.Info);
            }
    
            // 应用修改的属性
            serializedObject.ApplyModifiedProperties();
        }
    
        private void RefreshPoolInfo(GameObjectPool pool)
        {
            pool.RefreshInspectorInfo();
            _lastRefreshTime = Time.time;
            serializedObject.Update(); // 立即更新序列化对象
    
            // 标记需要重绘
            if (Selection.activeGameObject == pool.gameObject)
            {
                EditorUtility.SetDirty(pool);
                Repaint();
            }
        }
    
        private void DrawPoolInfos()
        {
            int poolCount = _poolInfosProperty.arraySize;
    
            // 确保折叠状态数组大小正确
            if (_poolFoldouts == null || _poolFoldouts.Length != poolCount)
            {
                bool[] oldPoolFoldouts = _poolFoldouts;
                bool[] oldPrefabFoldouts = _prefabFoldouts;
    
                _poolFoldouts = new bool[poolCount];
                _prefabFoldouts = new bool[poolCount];
    
                // 保持之前的折叠状态
                if (oldPoolFoldouts != null)
                {
                    for (int i = 0; i < Mathf.Min(oldPoolFoldouts.Length, poolCount); i++)
                    {
                        _poolFoldouts[i] = oldPoolFoldouts[i];
                        if (oldPrefabFoldouts != null && i < oldPrefabFoldouts.Length)
                        {
                            _prefabFoldouts[i] = oldPrefabFoldouts[i];
                        }
                    }
                }
            }
    
            for (int i = 0; i < poolCount; i++)
            {
                DrawPoolInfo(i);
            }
        }
    
        private void DrawPoolInfo(int poolIndex)
        {
            var poolInfo = _poolInfosProperty.GetArrayElementAtIndex(poolIndex);
            if (poolInfo == null) return;
    
            var configAssetProp = poolInfo.FindPropertyRelative("configAsset");
            var totalObjectsProp = poolInfo.FindPropertyRelative("totalObjects");
            var maxCountProp = poolInfo.FindPropertyRelative("maxCount");
            var activeObjectsProp = poolInfo.FindPropertyRelative("activeObjects");
    
            if (configAssetProp == null || totalObjectsProp == null || maxCountProp == null || activeObjectsProp == null)
                return;
    
            string configAsset = configAssetProp.stringValue;
            int totalObjects = totalObjectsProp.intValue;
            int maxCount = maxCountProp.intValue;
            int activeObjects = activeObjectsProp.intValue;
    
            EditorGUILayout.BeginVertical("box");
    
            // 使用Rect布局来精确控制Foldout的大小
            Rect rect = EditorGUILayout.GetControlRect();
            Rect foldoutRect = new Rect(rect.x, rect.y, 15, rect.height);
            Rect progressRect = new Rect(rect.x + 20, rect.y, rect.width - 120, rect.height);
            Rect labelRect = new Rect(rect.x + rect.width - 95, rect.y, 95, rect.height);
    
            // 绘制折叠按钮
            _poolFoldouts[poolIndex] = EditorGUI.Foldout(foldoutRect, _poolFoldouts[poolIndex], GUIContent.none);
    
            // 使用率进度条
            float usage = maxCount > 0 ? (float)totalObjects / maxCount : 0f;
            EditorGUI.ProgressBar(progressRect, usage, $"{configAsset} ({totalObjects}/{maxCount})");
    
            // 活跃对象数
            EditorGUI.LabelField(labelRect, $"活跃:{activeObjects}", EditorStyles.miniLabel);
    
            if (_poolFoldouts[poolIndex])
            {
                EditorGUI.indentLevel++;
                DrawPoolDetails(poolInfo, poolIndex);
                EditorGUI.indentLevel--;
            }
    
            EditorGUILayout.EndVertical();
            EditorGUILayout.Space();
        }
    
        private void DrawPoolDetails(SerializedProperty poolInfo, int poolIndex)
        {
            var configAssetProp = poolInfo.FindPropertyRelative("configAsset");
            var maxCountProp = poolInfo.FindPropertyRelative("maxCount");
            var expireTimeProp = poolInfo.FindPropertyRelative("expireTime");
            var loadedPrefabsProp = poolInfo.FindPropertyRelative("loadedPrefabs");
    
            if (configAssetProp != null)
                EditorGUILayout.LabelField($"配置路径: {configAssetProp.stringValue}");
            if (maxCountProp != null)
                EditorGUILayout.LabelField($"最大数量: {maxCountProp.intValue}");
            if (expireTimeProp != null)
                EditorGUILayout.LabelField($"过期时间: {expireTimeProp.floatValue}s");
            if (loadedPrefabsProp != null)
                EditorGUILayout.LabelField($"已加载预制体: {loadedPrefabsProp.intValue}");
    
            EditorGUILayout.Space();
    
            // 绘制预制体引用信息
            DrawPrefabRefs(poolInfo, poolIndex);
    
            // 绘制对象详细信息
            DrawObjectDetails(poolInfo);
        }
    
        private void DrawPrefabRefs(SerializedProperty poolInfo, int poolIndex)
        {
            var prefabRefsProp = poolInfo.FindPropertyRelative("prefabRefs");
            if (prefabRefsProp == null || prefabRefsProp.arraySize <= 0) return;
    
            // 使用简单的Foldout，不指定宽度
            _prefabFoldouts[poolIndex] = EditorGUILayout.Foldout(_prefabFoldouts[poolIndex], "预制体引用信息:");
    
            if (_prefabFoldouts[poolIndex])
            {
                EditorGUI.indentLevel++;
    
                for (int j = 0; j < prefabRefsProp.arraySize; j++)
                {
                    DrawPrefabRefInfo(prefabRefsProp.GetArrayElementAtIndex(j));
                }
    
                EditorGUI.indentLevel--;
            }
    
            EditorGUILayout.Space();
        }
    
        private void DrawPrefabRefInfo(SerializedProperty prefabRef)
        {
            if (prefabRef == null) return;
    
            var assetPathProp = prefabRef.FindPropertyRelative("assetPath");
            var refCountProp = prefabRef.FindPropertyRelative("refCount");
            var lastAccessTimeProp = prefabRef.FindPropertyRelative("lastAccessTime");
            var prefabObjProp = prefabRef.FindPropertyRelative("prefab");
    
            EditorGUILayout.BeginHorizontal("box");
    
            EditorGUILayout.BeginVertical();
            if (assetPathProp != null)
                EditorGUILayout.LabelField($"{System.IO.Path.GetFileName(assetPathProp.stringValue)}", EditorStyles.boldLabel);
            if (refCountProp != null)
                EditorGUILayout.LabelField($"引用计数: {refCountProp.intValue}", EditorStyles.miniLabel);
            if (lastAccessTimeProp != null)
                EditorGUILayout.LabelField($"最后访问: {(Time.time - lastAccessTimeProp.floatValue):F1}秒前", EditorStyles.miniLabel);
            EditorGUILayout.EndVertical();
    
            if (prefabObjProp != null)
                EditorGUILayout.ObjectField(prefabObjProp.objectReferenceValue, typeof(GameObject), false, GUILayout.Width(100));
    
            EditorGUILayout.EndHorizontal();
        }
    
        private void DrawObjectDetails(SerializedProperty poolInfo)
        {
            var objectsProp = poolInfo.FindPropertyRelative("objects");
            if (objectsProp == null || objectsProp.arraySize <= 0) return;
    
            EditorGUILayout.LabelField("对象详情:", EditorStyles.boldLabel);
    
            for (int j = 0; j < objectsProp.arraySize; j++)
            {
                DrawObjectInfo(objectsProp.GetArrayElementAtIndex(j));
            }
        }
    
        private void DrawObjectInfo(SerializedProperty obj)
        {
            if (obj == null) return;
    
            var objNameProp = obj.FindPropertyRelative("objectName");
            var objAssetPathProp = obj.FindPropertyRelative("assetPath");
            var isActiveProp = obj.FindPropertyRelative("isActive");
            var remainingTimeProp = obj.FindPropertyRelative("remainingTime");
            var expireProgressProp = obj.FindPropertyRelative("expireProgress");
            var gameObjectProp = obj.FindPropertyRelative("gameObject");
    
            EditorGUILayout.BeginHorizontal("box");
    
            // 状态颜色指示器
            bool isActive = isActiveProp?.boolValue ?? false;
            var statusColor = isActive ? Color.green : Color.yellow;
            var prevColor = GUI.color;
            GUI.color = statusColor;
            EditorGUILayout.LabelField("●", GUILayout.Width(15));
            GUI.color = prevColor;
    
            EditorGUILayout.BeginVertical();
    
            // 对象名称和路径
            string objName = objNameProp?.stringValue ?? "Unknown";
            string objAssetPath = objAssetPathProp?.stringValue ?? "";
            EditorGUILayout.LabelField($"{objName} ({System.IO.Path.GetFileName(objAssetPath)})", EditorStyles.boldLabel);
            EditorGUILayout.LabelField($"状态: {(isActive ? "活跃" : "空闲")}", EditorStyles.miniLabel);
    
            // 过期进度条
            if (!isActive && remainingTimeProp != null && expireProgressProp != null)
            {
                float remainingTime = remainingTimeProp.floatValue;
                float expireProgress = expireProgressProp.floatValue;
    
                if (remainingTime >= 0)
                {
                    Rect expireRect = GUILayoutUtility.GetRect(100, 16, GUILayout.ExpandWidth(true), GUILayout.Height(16));
                    EditorGUI.ProgressBar(expireRect, expireProgress, $"释放倒计时: {remainingTime:F1}s");
                }
            }
    
            EditorGUILayout.EndVertical();
    
            // GameObject引用
            if (gameObjectProp != null)
                EditorGUILayout.ObjectField(gameObjectProp.objectReferenceValue, typeof(GameObject), true, GUILayout.Width(100));
    
            EditorGUILayout.EndHorizontal();
        }
    
        public override bool RequiresConstantRepaint()
        {
            // 只有在选中对象池时才需要持续重绘
            var pool = target as GameObjectPool;
            return pool != null && pool.showDetailedInfo && Selection.activeGameObject == pool.gameObject;
        }
    }
}
#endif