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

运行中扩容怎么做不抖帧

运行中扩容怎么做不抖帧

对象池容量不足时,最危险的做法是“缺多少就这一帧创建多少”。扩容本身并不可怕,真正导致卡顿的是把大量实例化集中在高峰帧。更稳的策略是提前触发、分帧限额,并把可异步的准备工作与必须在主线程完成的实例化分开。

学习目标

  • 比较按需扩容、批量扩容和后台预热各自适用的场景
  • 用每帧创建预算把一次大扩容拆成连续的小步骤
  • 设计低水位触发与目标容量,避免池刚扩完又立刻再次触底

三种扩容策略怎么选

按需扩容最简单:借不到对象时立刻创建一个。它适合创建成本极低、峰值很小的对象,但高并发时会把创建成本直接叠加到业务高峰。

批量扩容是在容量不足或低于水位线时,把目标容量一次提高一批,但实际创建按帧限额执行。这样既减少频繁的小扩容,又不会把整批实例化塞进同一帧,通常是实时游戏最稳妥的默认方案。

“后台预热”需要拆开理解。纯数据准备、资源读取或引擎明确支持的异步加载可以放到后台;但很多引擎对象只能在主线程创建。例如 Unity 的 GameObject、Component 等 UnityEngine.Object 不应在工作线程直接实例化,因此常见做法是后台准备资源,主线程再分帧实例化。

策略 峰值帧风险 额外内存 适合场景
缺一个建一个 高 低 创建极轻、偶发不足
批量目标 + 分帧创建 低 中 子弹、特效、飘字等高频池
后台准备 + 主线程分帧实例化 最低 中到高 资源准备较重、可提前预测高峰

把扩容变成一条受预算控制的流程

运行时不要让“借用失败”直接触发无限创建。更稳的流程是:业务先提出目标容量,池记录 targetCapacity;随后每一帧只执行一次 GrowStep,创建数量受 maxCreatePerFrame 限制。达到目标后停止扩容。

对象池运行时扩容流程

下面的完整 C# 示例实现了一个最小的“目标容量 + 分帧扩容”控制器。示例从 96 扩到 120,每帧最多创建 6 个对象,因此不会在一帧内集中创建 24 个。

csharp
using System;
using System.Collections.Generic;

public sealed class PooledObject
{
    public int Id { get; }

    public PooledObject(int id)
    {
        Id = id;
    }
}

public sealed class BudgetedPool<T>
{
    private readonly Func<T> _factory;
    private readonly Stack<T> _available = new();

    public int Capacity { get; private set; }
    public int TargetCapacity { get; private set; }

    public BudgetedPool(int initialCapacity, Func<T> factory)
    {
        _factory = factory;
        TargetCapacity = initialCapacity;

        for (int i = 0; i < initialCapacity; i++)
        {
            _available.Push(_factory());
        }

        Capacity = initialCapacity;
    }

    public void EnsureCapacity(int requiredCapacity)
    {
        TargetCapacity = Math.Max(TargetCapacity, requiredCapacity);
    }

    public int GrowStep(int maxCreatePerFrame)
    {
        int remaining = TargetCapacity - Capacity;
        int createCount = Math.Min(maxCreatePerFrame, Math.Max(0, remaining));

        // 真正接入游戏主循环时,每帧只调用一次这个方法。
        for (int i = 0; i < createCount; i++)
        {
            _available.Push(_factory());
        }

        Capacity += createCount;
        return createCount;
    }
}

public static class Program
{
    public static void Main()
    {
        int nextId = 0;
        var pool = new BudgetedPool<PooledObject>(
            96,
            () => new PooledObject(++nextId));

        pool.EnsureCapacity(120);

        for (int frame = 1; frame <= 4; frame++)
        {
            int created = pool.GrowStep(maxCreatePerFrame: 6);
            int remaining = pool.TargetCapacity - pool.Capacity;

            Console.WriteLine(
                $"Frame {frame}: created={created}, " +
                $"capacity={pool.Capacity}, remaining={remaining}");
        }
    }
}

预期输出:

text
Frame 1: created=6, capacity=102, remaining=18
Frame 2: created=6, capacity=108, remaining=12
Frame 3: created=6, capacity=114, remaining=6
Frame 4: created=6, capacity=120, remaining=0

这个示例只演示容量增长控制,因此没有实现借出、归还和对象重置。接入真实对象池时,GrowStep 应放在主循环可控阶段,并让创建上限来自实际 Profiling 得到的帧预算,而不是固定照抄 6。

低水位要早于真正耗尽

如果池只在 available == 0 时才扩容,那么即使每帧创建量受控,当前请求仍可能拿不到对象。更稳的方式是设置低水位,例如可用对象低于 20% 时就提高目标容量。

目标容量也不要只补回原值。假设当前容量 100、低水位 20、业务预测下一波需要 130,可以把目标直接提高到 140 或 150,再按帧预算慢慢补齐。这样扩容是在“还够用”的时候发生,而不是等到资源耗尽才开始补救。

当需求已经瞬间超过现有容量时,分帧扩容无法凭空消除缺口。此时业务层必须明确降级策略,例如延迟非关键特效、复用低优先级对象,或允许少量临时创建。不要让对象池内部悄悄突破预算,否则最需要稳定的高峰帧反而最容易失控。

后台预热不要越过引擎线程边界

后台线程适合做不依赖主线程对象的准备,例如解析配置、计算生成参数、准备纯托管数据,或调用引擎明确声明为异步安全的资源接口。真正的场景对象实例化、组件挂接和物理对象注册,必须遵守所用引擎的线程规则。

因此“后台预热”更准确的结构是:提前预测需求,异步准备可准备的资源,主线程按预算完成对象创建,最后把新对象放回池中。这样既利用了空闲时间,也不会为了追求异步而引入线程安全问题。

用帧耗时而不是批次数量验收

固定“每帧创建 5 个”只是起点,因为不同对象的创建成本可能相差一个数量级。验收时应观察扩容期间的主线程耗时、帧时间 P95/P99、池耗尽次数和目标容量追赶时间。

如果某一帧扩容仍超过预算,就继续降低单帧创建量;如果长期追不上需求,则应提高初始容量、提早触发低水位,或在可预测场景进入前完成更多预热。稳定扩容的核心不是某个固定批次,而是让创建工作始终受帧预算和需求预测共同约束。

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

目录与阅读设置

阅读设置

17

记录一个想法

运行中扩容怎么做不抖帧

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

登录哪都通