C++实现多线程任务调度器：优化游戏引擎中的资源加载与并行更新 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

好的，我们开始吧。

C++多线程任务调度器：优化游戏引擎中的资源加载与并行更新

大家好，今天我们来深入探讨如何利用C++实现一个多线程任务调度器，并将其应用于优化游戏引擎中的资源加载与并行更新。在现代游戏开发中，CPU和GPU的性能瓶颈往往会导致帧率下降和游戏体验不佳。通过有效地利用多线程技术，我们可以显著提升资源加载速度、并行处理游戏逻辑，从而提高游戏的整体性能。

1. 任务调度器的概念与必要性

任务调度器，顾名思义，负责管理和调度程序中的任务。在单线程环境中，任务按顺序执行，效率较低。而多线程任务调度器可以将任务分配给多个线程并行执行，从而提高CPU利用率和程序的整体效率。

在游戏引擎中，资源加载（例如纹理、模型、音频）和游戏逻辑的更新（例如AI计算、物理模拟）是两个非常耗时的操作。如果这些操作都在主线程中执行，会导致游戏卡顿。通过将这些操作分配给多个线程并行执行，可以显著缩短加载时间、提高帧率。

2. C++多线程基础

在C++中，我们可以使用std::thread来创建和管理线程。以下是一些基本概念：

std::thread: 代表一个执行线程。
std::mutex: 用于保护共享资源，防止多个线程同时访问导致数据竞争。
std::lock_guard: RAII风格的互斥锁，在构造时自动加锁，析构时自动解锁。
std::condition_variable: 用于线程间的同步和通信，允许线程在特定条件满足时进入休眠状态，并在条件改变时被唤醒。
std::future / std::promise: 用于异步操作的结果传递。std::promise用于设置结果，std::future用于获取结果。

3. 任务调度器的设计与实现

我们的任务调度器需要满足以下几个基本需求：

任务队列: 存储待执行的任务。
线程池: 管理一组线程，用于执行任务。
任务分配机制: 将任务从队列中分配给空闲线程。
线程同步机制: 确保任务执行的正确性和线程安全。

以下是一个简单的任务调度器的C++实现：

#include <iostream>
#include <thread>
#include <vector>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <functional>

class TaskScheduler {
public:
    TaskScheduler(size_t numThreads) : stop(false) {
        threads.resize(numThreads);
        for (size_t i = 0; i < numThreads; ++i) {
            threads[i] = std::thread([this]() {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(queue_mutex);
                        condition.wait(lock, [this]() { return stop || !tasks.empty(); });
                        if (stop && tasks.empty()) {
                            return;
                        }
                        task = std::move(tasks.front());
                        tasks.pop();
                    }
                    task();
                }
            });
        }
    }

    ~TaskScheduler() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread &thread : threads) {
            thread.join();
        }
    }

    template<typename Func>
    void enqueue(Func f) {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            tasks.emplace(f);
        }
        condition.notify_one();
    }

private:
    std::vector<std::thread> threads;
    std::queue<std::function<void()>> tasks;
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
};

// 使用示例
int main() {
    TaskScheduler scheduler(4); // 创建一个包含4个线程的任务调度器

    for (int i = 0; i < 10; ++i) {
        scheduler.enqueue([i]() {
            std::cout << "Task " << i << " is running on thread " << std::this_thread::get_id() << std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟耗时操作
        });
    }

    std::this_thread::sleep_for(std::chrono::seconds(1)); // 等待任务完成
    return 0;
}

代码解释：

TaskScheduler 类: 实现了任务调度器的核心逻辑。
构造函数: 创建线程池，并启动线程。每个线程都在一个循环中等待任务。
析构函数: 设置 stop 标志，唤醒所有线程，并等待它们结束。
enqueue() 方法: 将任务添加到任务队列中，并通知一个等待的线程。
线程函数: 从任务队列中获取任务并执行，如果队列为空，则进入休眠状态。
互斥锁和条件变量: 用于保护任务队列和线程间的同步。

4. 优化游戏引擎中的资源加载

我们可以使用任务调度器来并行加载游戏资源。以下是一个简单的示例：

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
#include <thread>
#include <mutex>
#include <queue>
#include <condition_variable>

// 假设的纹理结构
struct Texture {
    int width;
    int height;
    std::vector<unsigned char> data;
};

// 加载纹理的函数
Texture LoadTextureFromFile(const std::string& filePath) {
    std::cout << "Loading texture from " << filePath << " on thread " << std::this_thread::get_id() << std::endl;
    // 模拟加载纹理的耗时操作
    std::this_thread::sleep_for(std::chrono::milliseconds(500));

    // 这里应该是真实的纹理加载逻辑，例如使用 stb_image 库
    // 为了简化，我们创建一个假的纹理
    Texture texture;
    texture.width = 256;
    texture.height = 256;
    texture.data.resize(texture.width * texture.height * 4, 255); // RGBA

    std::cout << "Texture loaded from " << filePath << std::endl;
    return texture;
}

// 使用任务调度器的纹理加载器
class TextureLoader {
public:
    TextureLoader(size_t numThreads) : scheduler(numThreads) {}

    void LoadTextureAsync(const std::string& filePath, std::function<void(Texture)> callback) {
        scheduler.enqueue([filePath, callback]() {
            Texture texture = LoadTextureFromFile(filePath);
            callback(texture);
        });
    }

private:
    TaskScheduler scheduler;
};

int main() {
    TextureLoader textureLoader(4); // 使用4个线程进行纹理加载

    std::vector<std::string> texturePaths = {
        "texture1.png",
        "texture2.png",
        "texture3.png",
        "texture4.png",
        "texture5.png"
    };

    std::vector<Texture> loadedTextures(texturePaths.size());
    std::vector<bool> textureLoaded(texturePaths.size(), false);
    std::mutex textureMutex;

    for (size_t i = 0; i < texturePaths.size(); ++i) {
        textureLoader.LoadTextureAsync(texturePaths[i], [&, i](Texture texture) {
            {
                std::lock_guard<std::mutex> lock(textureMutex);
                loadedTextures[i] = texture;
                textureLoaded[i] = true;
                std::cout << "Texture " << texturePaths[i] << " loaded and stored." << std::endl;
            }
        });
    }

    // 等待所有纹理加载完成
    while (true) {
        std::lock_guard<std::mutex> lock(textureMutex);
        bool allLoaded = true;
        for (bool loaded : textureLoaded) {
            if (!loaded) {
                allLoaded = false;
                break;
            }
        }
        if (allLoaded) {
            break;
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }

    std::cout << "All textures loaded!" << std::endl;

    // 现在可以使用 loadedTextures 中的纹理数据了

    return 0;
}

代码解释：

TextureLoader 类: 使用 TaskScheduler 来异步加载纹理。
LoadTextureAsync() 方法: 将纹理加载任务添加到任务队列中，并在加载完成后调用回调函数。
回调函数: 将加载的纹理数据存储到 loadedTextures 向量中，并设置 textureLoaded 标志。
主线程: 等待所有纹理加载完成，然后使用加载的纹理数据。

5. 并行更新游戏逻辑

类似地，我们可以使用任务调度器来并行更新游戏逻辑。例如，我们可以将游戏世界划分为多个区域，并为每个区域创建一个任务来更新其游戏逻辑。

#include <iostream>
#include <vector>
#include <thread>
#include <mutex>
#include <queue>
#include <condition_variable>

// 假设的游戏世界
class GameWorld {
public:
    GameWorld(int numRegions) : numRegions(numRegions) {
        regions.resize(numRegions);
        // 初始化游戏世界
        for (int i = 0; i < numRegions; ++i) {
            regions[i] = "Region " + std::to_string(i); // 简单地初始化区域的名字
        }
    }

    void UpdateRegion(int regionIndex) {
        std::cout << "Updating region " << regionIndex << " on thread " << std::this_thread::get_id() << std::endl;
        // 模拟更新游戏逻辑的耗时操作
        std::this_thread::sleep_for(std::chrono::milliseconds(200));

        // 这里应该是真实的更新游戏逻辑的代码
        regions[regionIndex] += " (Updated)"; // 简单地更新区域的名字

        std::cout << "Region " << regionIndex << " updated." << std::endl;
    }

    std::string GetRegionName(int regionIndex) const {
        return regions[regionIndex];
    }

private:
    int numRegions;
    std::vector<std::string> regions; // 存储各个区域的信息
};

// 使用任务调度器并行更新游戏世界
class GameWorldUpdater {
public:
    GameWorldUpdater(GameWorld& world, size_t numThreads) : world(world), scheduler(numThreads) {}

    void UpdateWorld() {
        for (int i = 0; i < world.numRegions; ++i) {
            scheduler.enqueue([&, i]() {
                world.UpdateRegion(i);
            });
        }
    }

private:
    GameWorld& world;
    TaskScheduler scheduler;
};

int main() {
    GameWorld world(8); // 创建一个包含8个区域的游戏世界
    GameWorldUpdater updater(world, 4); // 使用4个线程并行更新游戏世界

    updater.UpdateWorld();

    // 等待所有区域更新完成 (简单地等待一段时间，实际中需要更精确的同步机制)
    std::this_thread::sleep_for(std::chrono::seconds(1));

    std::cout << "Game world updated!" << std::endl;

    // 打印更新后的游戏世界
    for (int i = 0; i < world.numRegions; ++i) {
        std::cout << world.GetRegionName(i) << std::endl;
    }

    return 0;
}

代码解释：

GameWorld 类: 表示游戏世界，包含多个区域。
GameWorldUpdater 类: 使用 TaskScheduler 来并行更新游戏世界的各个区域。
UpdateWorld() 方法: 将每个区域的更新任务添加到任务队列中。
主线程: 启动更新任务，并等待所有区域更新完成。

6. 任务调度器的改进方向

以上实现只是一个简单的任务调度器，还有很多可以改进的地方：

优先级支持: 可以为任务设置优先级，让优先级高的任务优先执行。
任务依赖: 可以定义任务之间的依赖关系，确保任务按正确的顺序执行。
负载均衡: 可以根据线程的负载情况动态分配任务，避免某些线程过载，而另一些线程空闲。
异常处理: 可以捕获任务执行过程中抛出的异常，并进行处理，避免程序崩溃。
性能分析: 可以记录任务的执行时间，用于性能分析和优化。
更细粒度的同步机制： 使用原子操作、无锁数据结构等，减少锁的竞争。
任务窃取(Work Stealing): 当一个线程的任务队列为空时，可以从其他线程的任务队列中窃取任务执行，提高CPU利用率。

7. 其他优化策略

除了使用多线程任务调度器，还有一些其他的优化策略可以提高游戏引擎的性能：

数据局部性: 尽量让线程访问连续的内存区域，减少缓存未命中。
减少内存分配: 尽量重用对象，避免频繁的内存分配和释放。
使用SIMD指令: 使用SIMD指令可以并行处理多个数据，提高计算效率。
优化算法: 选择更高效的算法，减少计算量。
GPU优化: 尽量减少CPU和GPU之间的数据传输，优化渲染流程。

8. 权衡与选择

选择任务调度器和其他优化策略时，需要权衡以下因素：

开发成本: 实现和维护多线程代码的成本较高，需要更多的测试和调试。
复杂性: 多线程代码的复杂性较高，容易出现死锁、数据竞争等问题。
平台兼容性: 不同的平台对多线程的支持程度不同。
性能提升: 不同的优化策略对性能的提升效果不同。

在实际开发中，需要根据具体的项目需求和资源情况，选择合适的优化策略。

9. 示例：结合OpenGL的资源加载

这里提供一个与OpenGL结合的纹理加载示例，更贴近实际应用：

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
#include <thread>
#include <mutex>
#include <queue>
#include <condition_variable>
#include <glad/glad.h> // OpenGL 头部
#include <GLFW/glfw3.h> // GLFW 头部 (窗口管理)

// 假设的纹理结构
struct TextureData {
    int width;
    int height;
    unsigned char* data; // 指向纹理数据的指针
};

// 加载纹理的函数 (使用 stb_image 库或其他纹理加载库)
TextureData LoadTextureFromFile(const std::string& filePath) {
    std::cout << "Loading texture from " << filePath << " on thread " << std::this_thread::get_id() << std::endl;
    // 模拟加载纹理的耗时操作
    std::this_thread::sleep_for(std::chrono::milliseconds(500));

    // 这里应该是真实的纹理加载逻辑，例如使用 stb_image 库
    // 为了简化，我们创建一个假的纹理
    TextureData texture;
    texture.width = 256;
    texture.height = 256;
    texture.data = new unsigned char[texture.width * texture.height * 4]; // RGBA
    memset(texture.data, 255, texture.width * texture.height * 4); // 初始化为白色

    std::cout << "Texture loaded from " << filePath << std::endl;
    return texture;
}

// 释放纹理数据的函数
void FreeTextureData(TextureData& texture) {
    if (texture.data) {
        delete[] texture.data;
        texture.data = nullptr;
    }
}

// 使用任务调度器的纹理加载器
class TextureLoader {
public:
    TextureLoader(size_t numThreads) : scheduler(numThreads) {}

    void LoadTextureAsync(const std::string& filePath, std::function<void(GLuint, int, int)> callback) {
        scheduler.enqueue([filePath, callback]() {
            TextureData textureData = LoadTextureFromFile(filePath);

            // 在OpenGL上下文中创建纹理
            GLuint textureID;
            glGenTextures(1, &textureID);
            glBindTexture(GL_TEXTURE_2D, textureID);
            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, textureData.width, textureData.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, textureData.data);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

            // 调用回调函数，传递纹理ID和尺寸
            callback(textureID, textureData.width, textureData.height);

            // 释放纹理数据
            FreeTextureData(textureData);
        });
    }

private:
    TaskScheduler scheduler;
};

int main() {
    // 初始化 GLFW 和 OpenGL
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    GLFWwindow* window = glfwCreateWindow(800, 600, "Multi-threaded Texture Loading", NULL, NULL);
    if (window == NULL) {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);

    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

    glViewport(0, 0, 800, 600);

    TextureLoader textureLoader(4); // 使用4个线程进行纹理加载

    std::vector<std::string> texturePaths = {
        "texture1.png",
        "texture2.png",
        "texture3.png",
        "texture4.png",
        "texture5.png"
    };

    std::vector<GLuint> textureIDs(texturePaths.size(), 0);
    std::vector<int> textureWidths(texturePaths.size(), 0);
    std::vector<int> textureHeights(texturePaths.size(), 0);
    std::vector<bool> textureLoaded(texturePaths.size(), false);
    std::mutex textureMutex;

    for (size_t i = 0; i < texturePaths.size(); ++i) {
        textureLoader.LoadTextureAsync(texturePaths[i], [&, i](GLuint textureID, int width, int height) {
            {
                std::lock_guard<std::mutex> lock(textureMutex);
                textureIDs[i] = textureID;
                textureWidths[i] = width;
                textureHeights[i] = height;
                textureLoaded[i] = true;
                std::cout << "Texture " << texturePaths[i] << " loaded and OpenGL texture created." << std::endl;
            }
        });
    }

    // 渲染循环
    while (!glfwWindowShouldClose(window)) {
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        // 在这里使用加载的纹理进行渲染
        for (size_t i = 0; i < texturePaths.size(); ++i) {
            std::lock_guard<std::mutex> lock(textureMutex);
            if (textureLoaded[i]) {
                // 绑定纹理并渲染一个简单的四边形
                glBindTexture(GL_TEXTURE_2D, textureIDs[i]);
                // 这里省略了shader和顶点数据的设置，只展示纹理绑定
                // 渲染代码...

                // 简单示例，只是为了避免编译器优化掉代码
                glDrawArrays(GL_TRIANGLES, 0, 6); // 假设渲染一个三角形
            }
        }

        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    // 清理
    for(GLuint id : textureIDs) {
        glDeleteTextures(1, &id);
    }
    glfwTerminate();
    return 0;
}

关键点：

OpenGL 上下文: 纹理的创建和操作必须在OpenGL上下文中进行。确保在调用 glGenTextures、glBindTexture、glTexImage2D 等函数之前，已经使用 glfwMakeContextCurrent(window) 设置了当前线程的OpenGL上下文。
线程安全: OpenGL对象（例如纹理ID）可以在多个线程中使用，但对OpenGL状态的修改必须在同一个线程中进行。在本示例中，纹理的创建和初始化都在任务调度器的线程中完成，并且通过回调函数将纹理ID传递回主线程进行渲染。
资源释放: 确保在程序结束时释放OpenGL资源，防止内存泄漏。

需要注意的细节：

OpenGL的线程模型: OpenGL的设计并非完全线程安全，某些操作只能在创建OpenGL上下文的线程中执行。
上下文切换: 在多线程中使用OpenGL时，频繁的上下文切换会带来性能开销。尽量避免在多个线程中频繁地切换OpenGL上下文。
扩展库: 使用如stb_image的图片加载库进行真实图片的加载。

总结：

任务调度器可以有效地利用多核CPU，提高游戏引擎的性能。
在资源加载和游戏逻辑更新中使用任务调度器可以显著缩短加载时间、提高帧率。
需要仔细考虑线程安全、数据局部性、负载均衡等因素，才能充分发挥任务调度器的优势。
OpenGL的线程模型有其特殊性，需要在多线程环境中使用OpenGL时特别注意。

通过合理地使用多线程任务调度器和其他优化策略，我们可以构建出性能卓越的游戏引擎，为玩家带来流畅、逼真的游戏体验。

更多IT精英技术系列讲座，到智猿学院

C++多线程任务调度器：优化游戏引擎中的资源加载与并行更新

发表回复 取消回复

发表回复取消回复