本文仅作为个人在学习过程中的记录,如有错误,欢迎指出!

引用计数与追踪式标记-清除

垃圾回收(GC)的核心职责是在对象不再被使用时安全地结束其生命周期并回收其占用的内存,杜绝内存泄漏或悬空野指针。

引用计数

对于现代 C++,更多的是依托 RAII 管理资源。当多个所有者需要共享所有权时,常借助引用计数来管理销毁。

问题:

  1. 每个对象需要额外维护一份原子计数器。

  2. 对于跨线程赋值,会触发原子操作,严重拖慢主循环。

  3. 同时还需要处理循环引用,需准确使用弱引用。

  4. 内存释放随时可能发生,容易产生突发卡顿。

追踪式标记-清除

商业级游戏引擎几乎无一例外采用追踪式标记-清除(Tracing Mark-and-Sweep)。

优势:

  1. 集中在全局对象表中管理。

  2. 运行时对象赋值即作为普通指针写入,无原子开销。

  3. 对于存在循环引用的对象,只要这类对象无法从根节点触达,则会被一并清理。

  4. 集中或增量调度,执行时机确定,利于帧时间预算控制。

集中调度:GC 在一次回收过程中集中完成大量工作,可能导致某一帧耗时突然增加。

增量调度:将 GC 工作拆成多个小步骤,分散到不同帧执行,降低单帧卡顿风险。

帧时间预算:规定每帧允许某项工作消耗多少时间。GC 尽量在预算范围内完成部分任务,剩余工作留到后续帧。

虚幻引擎 GC 方式选择

虚幻引擎以 追踪式 Mark-and-Sweep 为核心构建了整套对象生命周期管理体系。

flowchart TD
    Root["GC 根集合 (Root Set)<br/>例如: GEngine, GameInstance, World, AddToRoot"]
    
    Root --> Obj1["活动对象 A"]
    Obj1 --> Obj2["活动对象 B"]
    
    subgraph Island["无法从 Root 触达的强引用孤岛"]
        ObjC["对象 C"] <-->|"相互强引用"| ObjD["对象 D"]
    end
    
    Root -.->|"不可达"| Island
    
    style Island fill:#fff0f0,stroke:#f66,stroke-dasharray: 5 5
    style Root fill:#e8f4fc,stroke:#39f

每一轮 GC 当中,引擎都会从根集合出发,对于不可达的部分,就会当作垃圾进行回收。

GC 的数据库

首先需要搞清楚,GC 它是怎么知道有哪些 UObject 的。

GUObjectArray

所有 UObject 实例在创建时都会在全局对象表 GUObjectArray 中注册。

extern COREUOBJECT_API FUObjectArray GUObjectArray;

GUObjectArray 负责对象注册、索引分配与回收等工作。

其中 ObjObjects 负责保存对象。

TUObjectArray ObjObjects;

FUObjectItem

FUObjectItem 是数组中的一个槽位,保存对象的指针以及内部状态:

struct FUObjectItem
{
	// 指向实际的 UObject
	class UObjectBase* Object;

	// 内部状态标记(EInternalObjectFlags)
	int32 Flags;

	// 所属 GC 簇根节点索引
	int32 ClusterRootIndex;	

	// Weak Object Pointer Serial number associated with the object
	int32 SerialNumber;
};

GC 中常用的 Flag:

可达性

// Reachable 
EInternalObjectFlags GReachableObjectFlag = EInternalObjectFlags::ReachabilityFlag0;

// Unreachable
EInternalObjectFlags GUnreachableObjectFlag = EInternalObjectFlags::ReachabilityFlag1;

// MaybeUnreachable
EInternalObjectFlags GMaybeUnreachableObjectFlag = EInternalObjectFlags::ReachabilityFlag2;

根集合

GC 算法不可能凭空猜测从哪里开始扫描,它必须依赖一组必定存活的源头,即 根集合(Root Set)。

哪些属于根集合?

  1. 引擎核心全局单例:GEngine、UGameEngine 等顶级系统对象。

  2. 游戏主链路核心:活动关卡中的 UWorld、UGameInstance、挂载在世界中的主 Level。

  3. 显式根对象:通过 C++ 手动调用了 Object->AddToRoot() 的任何 UObject。注意需要显式调用 RemoveFromRoot(),否则永远不会被 GC 回收。

如何接入 GC ?

有了这个根集合之后,还需要知道这个根对象它可以一路触达哪些下游对象。

UPROPERTY 宏

通过 UPROPERTY() 宏,将成员变量纳入 UE 的反射系统,使 GC 能够识别其中的 UObject 引用。

FGCObject

对于原生 C++ 类可以主动进行备份。

#include "UObject/GCObject.h"

class FCustomNativeManager : public FGCObject
{
public:
    UTexture2D* CachedIcon = nullptr;

    // 重写 FGCObject 核心虚函数
    virtual void AddReferencedObjects(FReferenceCollector& Collector) override
    {
        // 主动向 GC 报备:我手头持有着这个 UObject,请把它算作可达!
        Collector.AddReferencedObject(CachedIcon);
    }
};
  1. FGCObject 在构造函数中会自动将自身指针注册进全局链表 FGCObject::GGCObjectList。
  2. 在 GC 的 Mark 阶段,引擎会自动轮询遍历这批原生对象,调用它们的 AddReferencedObjects,从而将原生类中的 UObject* 纳入可达性图谱!

img

注意区分前面提到的全局对象表。

标记-清除(Mark & Sweep)全流程

sequenceDiagram
    participant Engine as 游戏线程 / GC 调度器
    participant Workers as 并发 GC 工作线程 (TaskGraph)
    participant Pool as GUObjectArray 全局对象池
    participant WeakTable as 全局弱引用表
    
    Note over Engine,Workers: 1. 标记阶段 (Mark Phase)
    Engine->>Workers: 收集 Root Set,派发并发标记任务
    Workers->>Workers: 沿 TokenStream 与 AddReferencedObjects 拓扑遍历
    Workers->>Pool: 为所有被触达的对象打上 Reachable 标记
    
    Note over Engine,WeakTable: 2. 弱引用置空 (Weak Reference Clearing)
    Engine->>WeakTable: 扫描所有 FWeakObjectPtr
    WeakTable->>WeakTable: 发现目标未打上 Reachable -> 自动将指针置 nullptr
    
    Note over Engine,Pool: 3. 清除阶段 (Sweep Phase)
    Engine->>Pool: 遍历 GUObjectArray
    Pool->>Engine: 找到未打上 Reachable 的孤岛对象
    Engine->>Engine: 执行两段式销毁 (BeginDestroy -> FinishDestroy)
    Engine->>Pool: 回收 FUObjectItem 槽位,释放内存

1. 标记阶段

从根集合出发,将下游对象压入任务队列。UE 借助 TaskGraph 将队列中的对象分发给多个后台工作线程并发处理,为所有可触达的对象打上可达标签。

2. 弱引用置空

扫描所有的弱指针,若指向的目标对象未被标记可达,则将指向设置为空。

3. 清除阶段

遍历全局对象表,找到所有不可达对象,并调用析构。

为防止单帧内销毁过多数量对象导致画面卡顿,UE 采用增量清除:限制每帧最多消耗的时间片预算(如 2 毫秒),没清理完的对象留到下一帧继续清除,确保平稳帧率。

GC Clusters

这是性能优化的一种手段,通过将存在紧密关系的 UObject 组织成一个整体,正常情况下,GC 需要沿着对象间的引用关系逐个检查;启用 Cluster 后,引擎可以将这组对象视作一个整体来处理。

img

普通 GC:从可达对象出发,遍历对象之间的引用关系。

当对象规模达到几千甚至几万个时,引用遍历会产生明显开销。

img

Cluster GC:簇内部的稳定引用关系不必在每轮 GC 中重复逐个扫描。

原本大量的对象级引用分析,可以转化为更少的簇级引用分析。

源码相关

extern COREUOBJECT_API FUObjectClusterContainer GUObjectClusters;

容器中存放着簇的数组

class FUObjectClusterContainer
{
	/** List of all clusters */
	TArray<FUObjectCluster> Clusters;
	/** List of available cluster indices */
	TArray<int32> FreeClusterIndices;
	/** Number of allocated clusters */
	int32 NumAllocatedClusters;
	/** Clusters need dissolving, probably due to PendingKill reference */
	bool bClustersNeedDissolving;
}

每个簇的结构

struct FUObjectCluster
{
    // 簇根对象在 GUObjectArray 中的索引
    int32 RootIndex;

    // 属于该簇的对象
    TArray<int32> Objects;

    // 无法直接加入簇,但仍需追踪的对象
    TArray<int32> MutableObjects;

    // 当前簇引用的其他簇
    TArray<int32> ReferencedClusters;

    // 引用了当前簇的其他簇
    TArray<int32> ReferencedByClusters;

    // 是否需要解散
    bool bNeedsDissolving;
};

可以看到,簇之间也可以存在引用关系。

对象消亡的历程

函数中调用 Destroy() 并不意味着 delete,具体内存释放由引擎决定。

  1. Actor->Destroy() | 此后 IsValid() 无效。

  2. Actor 退出游戏世界,执行 EndPlay。

  3. 等待 GC 识别并处理待回收对象。

  4. 下一轮 GC 收集周期。

  5. GC 调用 ConditionalBeginDestroy() 触发 Actor->BeginDestroy(),发起必要的异步资源清理,例如向渲染线程发送异步释放命令。

  6. 等待其他线程释放 IsReadyForFinishDestroy() false → 暂缓销毁,后续重新检查 | true → ConditionalFinishDestroy()。

  7. FinishDestroy() C++ 析构与内存回收。

为什么要有两段式析构?

游戏引擎的大量资源(如网格体显存、材质渲染句柄)是由渲染线程异步消费的。如果在游戏线程里直接 delete,渲染线程同一时刻正在访问该网格体,立刻引发空地址异常。

因此,ConditionalBeginDestroy 负责发出清理通知,等待各异步子系统就绪后,再由 FinishDestroy 完成最终的物理内存释放。

常用指针

指针形式底层对应属性GC 影响是否必须 UPROPERTY?核心适用场景
TObjectPtr<T> / T\*FObjectProperty强引用。只要持有者活着,目标对象就绝不会被回收强力必须。不加宏则 GC 无法得知偏移,会导致致命野指针崩溃拥有所有权的组件、核心子对象、明确的依赖项
TWeakObjectPtr<T>FWeakObjectPtr弱引用。不提供保活;目标销毁后自动置空加不加宏均可运作观察者监听、防止循环强引用、引用非属主对象
TSoftObjectPtr<T>FSoftObjectProperty软引用。仅保存资产路径,绝不常驻内存必须加宏才能在编辑器显示资产拖拽框大型地图资产异步加载、按需载入、解耦硬打包引用