游戏客户端架构 / 系统课时

闲置对象多久应该回收

闲置对象多久应该回收

对象池不是越大越安全。长时间运行的关卡里,如果峰值过后仍永久保留所有实例,池本身会变成稳定的内存占用来源。本节用“空闲超时 + 容量上限 + 周期回收”三条规则,让对象池在保留复用收益的同时,能在负载下降后主动缩容。

学习目标

  • 为对象池设计可解释的空闲超时和最小保留容量
  • 用容量上限限制异常峰值后的长期驻留
  • 实现周期回收,并验证不会误删正在使用的对象

回收规则先解决三个边界

一个可长期运行的对象池通常要区分“正在使用”和“已归还但闲置”两类对象。回收只针对后者,而且不能只看当前池大小,否则刚归还的热点对象也可能立刻被销毁。

可以把规则定成三层:池中空闲对象超过 minRetained 才允许缩容;单个对象连续空闲超过 idleTimeout 才具备回收资格;即使还没超时,只要空闲数量超过 maxIdle,也要优先删除最久未使用的对象。

空闲对象池的周期缩容决策流程

这三条规则的作用不同:minRetained 防止池缩到太小,idleTimeout 避免短暂低谷触发抖动,maxIdle 则兜住突发峰值留下的大量对象。实际项目中通常三者一起使用,而不是只设一个“多久销毁”。

用时间戳记录最后归还时间

下面是 Unity C# 的核心实现片段。它依赖项目提供对象创建函数,并由外部管理器周期调用 Sweep,因此不是可独立运行的控制台程序。池只保存空闲对象;借出后从空闲队列移除,归还时记录时间。

csharp
using System;
using System.Collections.Generic;
using UnityEngine;

public sealed class TimedGameObjectPool
{
    private sealed class Entry
    {
        public GameObject Instance;
        public float ReturnedAt;
    }

    private readonly Queue<Entry> idle = new();
    private readonly Func<GameObject> factory;
    private readonly int minRetained;
    private readonly int maxIdle;
    private readonly float idleTimeoutSeconds;

    public TimedGameObjectPool(
        Func<GameObject> factory,
        int minRetained,
        int maxIdle,
        float idleTimeoutSeconds)
    {
        if (minRetained < 0) throw new ArgumentOutOfRangeException(nameof(minRetained));
        if (maxIdle < minRetained) throw new ArgumentOutOfRangeException(nameof(maxIdle));
        if (idleTimeoutSeconds < 0f) throw new ArgumentOutOfRangeException(nameof(idleTimeoutSeconds));

        this.factory = factory ?? throw new ArgumentNullException(nameof(factory));
        this.minRetained = minRetained;
        this.maxIdle = maxIdle;
        this.idleTimeoutSeconds = idleTimeoutSeconds;
    }

    public GameObject Rent()
    {
        if (idle.Count == 0)
            return factory();

        var entry = idle.Dequeue();
        entry.Instance.SetActive(true);
        return entry.Instance;
    }

    public void Return(GameObject instance)
    {
        instance.SetActive(false);
        idle.Enqueue(new Entry
        {
            Instance = instance,
            ReturnedAt = Time.unscaledTime
        });
    }

    public int Sweep()
    {
        int removed = 0;
        int initialCount = idle.Count;

        for (int i = 0; i < initialCount; i++)
        {
            var entry = idle.Dequeue();
            float idleSeconds = Time.unscaledTime - entry.ReturnedAt;

            bool aboveMinimum = idle.Count + 1 > minRetained;
            bool expired = idleSeconds >= idleTimeoutSeconds;
            bool aboveMaximum = idle.Count + 1 > maxIdle;

            if (aboveMinimum && (expired || aboveMaximum))
            {
                UnityEngine.Object.Destroy(entry.Instance);
                removed++;
                continue;
            }

            idle.Enqueue(entry);
        }

        return removed;
    }

    public int IdleCount => idle.Count;
}

生效行为是:扫描只处理 idle 队列中的实例,借出的对象根本不在回收集合中。队列按归还顺序保存对象,所以容量超限时会先检查较早归还的实例。

假设 minRetained = 10、maxIdle = 40、idleTimeoutSeconds = 30,一次峰值后归还了 60 个对象,扫描会删除超过容量上限的旧空闲实例;随着对象继续超时,后续扫描还可以继续缩容,但不会主动降到 10 个以下。

预期结果可以通过扫描前后记录空闲数和删除数验证。时间与删除数量属于运行时动态值,因此使用占位符表示。

text
Idle before sweep: 60
Removed: <COUNT>
Idle after sweep: <COUNT>

验证重点不是得到固定的 <COUNT>,而是确认空闲数不会低于 minRetained,并且超时对象或超过 maxIdle 的对象能够退出池。

周期频率不要等于帧频率

回收属于维护操作,不需要每帧执行。若对象池有数百或数千个空闲元素,每帧全量扫描会把“省下来的创建销毁成本”换成持续扫描成本。

常见做法是每 5~30 秒执行一次 Sweep,或者在场景阶段切换、战斗波次结束、房间卸载前触发。回收间隔应明显小于能够接受的内存滞留时间,但没有必要精确到毫秒。

参数应该由负载数据决定

idleTimeout 不应凭感觉设置。先记录真实运行中的峰值空闲数、峰值持续时间、两次负载高峰的间隔,以及对象单个实例的大致内存成本。如果高峰通常每 20 秒出现一次,把超时设为 5 秒就可能反复销毁和重建;如果高峰间隔常超过 10 分钟,长期保留几百个实例又可能浪费内存。

容量上限也要区分对象成本。几十个简单子弹对象可以长期保留,而包含粒子系统、骨骼动画和大量资源引用的复杂对象通常需要更谨慎的上限。目标不是“池越小越好”,而是在下一次复用概率和当前驻留成本之间取得稳定平衡。

验证回收没有破坏复用

测试时至少观察三件事:回收只发生在空闲集合;高峰结束后内存能够回落;下一次普通负载到来时不会连续触发大量实例化。若缩容后马上又出现创建尖峰,通常说明 idleTimeout 太短或 minRetained 太低。

合理的运行曲线应当是高峰时允许池扩张,低谷持续一段时间后再逐步缩小,最终稳定在常见负载附近。这样对象池才是在吸收运行负载的波动,而不是把频繁创建销毁从业务代码搬到了另一个地方。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

闲置对象多久应该回收

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通