榨干 CPU 多核性能：虚幻引擎 Task Graph 任务图深度解析与实战指南

#include "Async/TaskGraphInterfaces.h"

// 假设的数据结构：
// FWorldChunk: 代表一个地图分块
// UWorldModifier: 代表一个地图生成/修改器（如河流生成器、植被生成器等）

void ApplyModifiersParallel(const TArray<const UWorldModifier*>& Modifiers)
{
    // 1. 用于记录每个 Chunk 最新一次被修改的任务 Event，用来构建依赖链
    TMap<FWorldChunk*, FGraphEventRef> ChunkLastEventMap;

    // 收集所有派发出去的任务 Event，以便最后统一等待
    FGraphEventArray AllTaskEvents;

    // 预先分配结果空间，避免多线程向同一个 Array 写入时的锁竞争
    TArray<TArray<FChunkModifyResult>> AllResults;
    AllResults.SetNum(Modifiers.Num());

    // ==========================================
    // 第一阶段：在游戏线程中快速构建“任务依赖图”
    // ==========================================
    for (int32 ModIndex = 0; ModIndex < Modifiers.Num(); ++ModIndex)
    {
        const UWorldModifier* Modifier = Modifiers[ModIndex];
        
        // 获取当前修改器关联的所有 Chunk 列表
        TArray<FWorldChunk*> AffectedChunks = Modifier->GetAffectedChunks();
        if (AffectedChunks.Num() == 0) continue;

        // 收集该任务的前置依赖（Prerequisites）
        // 如果当前任务要修改的 Chunk 正在被之前的任务占用，就必须等之前的任务完成
        FGraphEventArray Prereqs;
        for (FWorldChunk* Chunk : AffectedChunks)
        {
            if (FGraphEventRef* LastEvent = ChunkLastEventMap.Find(Chunk))
            {
                Prereqs.Add(*LastEvent);
            }
        }

        // 创建并派发异步任务
        FGraphEventRef CurrentTaskEvent = FFunctionGraphTask::CreateAndDispatchWhenReady(
            [Modifier, AffectedChunks, ModIndex, &AllResults]()
            {
                // 【线程安全保证】：
                // 此时，本任务依赖的所有 Chunk 绝对不会被其他任何后台线程修改，
                // 我们可以安全地顺序处理该 Modifier 关联的所有 Chunk。
                TArray<FChunkModifyResult> LocalResults;
                for (FWorldChunk* Chunk : AffectedChunks)
                {
                    FChunkModifyResult Result = Modifier->Apply(Chunk);
                    LocalResults.Add(Result);
                }
                
                // 写入各自预分配的对应槽位，完美避开多线程写冲突
                AllResults[ModIndex] = MoveTemp(LocalResults);
            },
            TStatId(),
            &Prereqs // 传入依赖：只有 Prereqs 里的任务全部完工，本任务才启动
        );

        // 登记/更新这些 Chunk 的最新占用任务，供后面的 Modifier 依赖
        for (FWorldChunk* Chunk : AffectedChunks)
        {
            ChunkLastEventMap.Add(Chunk, CurrentTaskEvent);
        }

        AllTaskEvents.Add(CurrentTaskEvent);
    }

    // ==========================================
    // 第二阶段：阻塞并等待所有任务完成
    // ==========================================
    if (AllTaskEvents.Num() > 0)
    {
        // 阻塞当前线程，等待 Task Graph 自动调度并执行完所有任务
        // 期间主线程也会主动去队列里领任务干活，绝不闲置
        FTaskGraphInterface::Get().WaitUntilTasksComplete(AllTaskEvents);
    }

    // ==========================================
    // 第三阶段：安全收尾
    // ==========================================
    // 此时后台所有计算已 100% 结束，主线程可以安全地汇总结果
    for (const TArray<FChunkModifyResult>& ModResults : AllResults)
    {
        for (const FChunkModifyResult& Result : ModResults)
        {
            UpdateChunks.Add(Result);
        }
    }
}

tf::Executor executor;
tf::Taskflow taskflow;

// 声明任务
auto [A, B, C, D] = taskflow.emplace(
    []() { std::cout << "Task A\n"; },
    []() { std::cout << "Task B\n"; },
    []() { std::cout << "Task C\n"; },
    []() { std::cout << "Task D\n"; }
);

// 声明依赖：A 先执行，然后 B 和 C 并行，最后 D 执行
A.precede(B, C); 
D.succeed(B, C); 

executor.run(taskflow).wait();