14.3 多线程渲染
资源加载是后台化的重头戏:解码贴图、解析网格不该卡主线程。ResourceBackgroundQueue 把「资源操作」翻译成「WorkQueue 上的任务」,每个方法都返回 std::future<void>,主线程可以随时查进度。它本身不再带锁——并行化全部收敛在 WorkQueue 里(源文件注释明说「this class is entirely single-threaded」)。这一节看它怎么用 packaged_task 包装、怎么按线程支持拆 prepare/load。
本章与站内既有内容的分工
14.2 的 WorkQueue 是通用任务队列,这一节的 ResourceBackgroundQueue 是它的资源专用门面;卷一 ogre-core 的 ResourceGroupManager::loadResourceGroup 是真正干活的函数,这里只决定它在哪个线程跑。与 cg 三卷无关,此节是线程模型设计。
资源后台队列的定位
ResourceBackgroundQueue 是单例,所有操作都借道 Root::getWorkQueue() 共享线程池。头文件开头就写清了「future 何时 ready、监听回调何时跑」:
// OgreMain/include/OgreResourceBackgroundQueue.h:ResourceBackgroundQueue 类说明(v14.6.3 源码摘录,已删减)
Every call returns a `std::future<void>` that becomes ready when the
background portion of the operation has finished. This may be before the
corresponding Resource::Listener callback has run, because those callbacks
are dispatched back to the main thread. Use the future to wait for the data
to become available, and a listener to observe the completed resource.
Which resource methods can run on a worker thread depends on
`OGRE_THREAD_SUPPORT`. With the default configuration (3), workers cannot
access the RenderSystem: prepare() runs Resource::prepare in the background,
while load() prepares in the background and performs the actual load on the
main thread. With `OGRE_THREAD_SUPPORT == 1`, resources are fully thread-safe
and load() runs entirely in the background.
两句话是理解全文的关键:
| 概念 | 语义 |
|---|---|
| future 何时 ready | 后台部分结束即 ready,早于主线程的监听回调 |
| 监听回调在哪跑 | _firePreparingComplete/_fireLoadingComplete 派回主线程泵 |
| 默认配置(THREAD_SUPPORT=3) | 后台不能碰 RenderSystem:prepare 后台、load 的主线程部分回主线程 |
| THREAD_SUPPORT=1 | 资源全线程安全,load 整个在后台跑 |
packaged_task + future:包装范式
每个公共方法都是同一个三步:造 packaged_task → addTask 投递 → 返回 get_future()。以 prepare 为例:
// OgreMain/src/OgreResourceBackgroundQueue.cpp:ResourceBackgroundQueue::prepare(v14.6.3 源码摘录,已删减)
std::future<void> ResourceBackgroundQueue::prepare(const ResourcePtr& res)
{
auto task = std::make_shared<std::packaged_task<void()>>(
[res]()
{
res->prepare(true);
Root::getSingleton().getWorkQueue()->addMainThreadTask([res]() { res->_firePreparingComplete(); });
});
Root::getSingleton().getWorkQueue()->addTask([task]() { (*task)(); });
return task->get_future();
}
std::make_shared<std::packaged_task<void()>> 包住 ResourcePtr,lambda 里干两件事:后台跑 res->prepare(true),再把 _firePreparingComplete 派回主线程队列。addTask 的捕获 [task] 让队列持有 packaged_task 的共享所有权;任务执行时 (*task)() 真正跑。get_future() 让调用方拿到就绪信号。
load 的分阶段拆解
load 是拆分的集大成者:根据 OGRE_THREAD_SUPPORT 走两条路。默认配置下后台只做 prepare,真正的 load 连同 _fireLoadingComplete 一起回主线程:
// OgreMain/src/OgreResourceBackgroundQueue.cpp:ResourceBackgroundQueue::load(v14.6.3 源码摘录,已删减)
std::future<void> ResourceBackgroundQueue::load(const ResourcePtr& res)
{
auto task = std::make_shared<std::packaged_task<void()>>(
[res]()
{
#if OGRE_THREAD_SUPPORT == 1
res->load(true);
Root::getSingleton().getWorkQueue()->addMainThreadTask([res]() { res->_fireLoadingComplete(); });
#else
res->prepare(true);
Root::getSingleton().getWorkQueue()->addMainThreadTask(
[res]()
{
res->load(true);
res->_fireLoadingComplete();
});
#endif
});
Root::getSingleton().getWorkQueue()->addTask([task]() { (*task)(); });
return task->get_future();
}
| 分支 | 后台线程做 | 主线程队列做 |
|---|---|---|
OGRE_THREAD_SUPPORT == 1 | load(true) | 仅 _fireLoadingComplete |
默认(!= 1) | prepare(true) | load(true) + _fireLoadingComplete |
注意默认分支里 future 在后台 prepare 结束时已 ready,而资源真正 load 完还在主线程泵之后——这正是头文件那句「future 可能早于监听回调」的实例。资源组级的 initialiseResourceGroup/loadResourceGroup 用同一包装范式,只是 lambda 调 ResourceGroupManager 的对应函数。
源码定位
OgreMain/include/OgreResourceBackgroundQueue.h:类说明(49-71)、公共方法声明(82-125)OgreMain/src/OgreResourceBackgroundQueue.cpp:initialiseResourceGroup(50-56)、loadResourceGroup(74-88)、prepare(90-100)、load(102-122)、unload(124-129)
上游引用固定到 OGRE v14.6.3 源码 。
可运行产物:C++ 最小验证
下面复现 packaged_task 包装、后台/主线程拆分与静默丢弃。它与 src/14-3-multithread-render.cpp 逐字节一致:
// file: src/14-3-multithread-render.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/14-3-multithread-render.cpp -o bin/14-3-multithread-render && ./bin/14-3-multithread-render
//
// 复现 ResourceBackgroundQueue 的 packaged_task 包装与「后台 prepare、主线程 load」拆分
// (对应 OgreResourceBackgroundQueue.cpp 50-137 与 OgreResourceBackgroundQueue.h 49-71):
// 每次操作包成 std::packaged_task 交给 WorkQueue::addTask,返回 std::future<void>;
// OGRE_THREAD_SUPPORT != 1 时 load 在后台做 prepare,再把真正 load 派给主线程队列;
// 后台任务被静默丢弃时 prepare 永不发生。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"
#include <chrono>
#include <cstddef>
#include <deque>
#include <functional>
#include <future>
#include <memory>
namespace ogre_repro {
class ResourceRepro {
public:
void prepare(bool) { mPrepared = true; }
void load(bool) { mLoaded = true; }
void _firePreparingComplete() {}
void _fireLoadingComplete() {}
bool isPrepared() const { return mPrepared; }
bool isLoaded() const { return mLoaded; }
private:
bool mPrepared = false;
bool mLoaded = false;
};
// 简化版 DefaultWorkQueueBase(对应 OgreWorkQueue.cpp 的双队列)
class WorkQueueRepro {
public:
void addTask(std::function<void()> task) {
if (!mAcceptRequests || mShuttingDown) return;
mTasks.push_back(std::move(task));
}
void addMainThreadTask(std::function<void()> task) {
if (!mAcceptRequests || mShuttingDown) return;
mMainTasks.push_back(std::move(task));
}
void setRequestsAccepted(bool accept) { mAcceptRequests = accept; }
void _processNextRequest() {
if (mTasks.empty()) return;
std::function<void()> task = std::move(mTasks.front());
mTasks.pop_front();
task();
}
void processMainThreadTasks() {
while (!mMainTasks.empty()) {
std::function<void()> task = std::move(mMainTasks.front());
mMainTasks.pop_front();
task();
}
}
size_t pendingBackground() const { return mTasks.size(); }
size_t pendingMain() const { return mMainTasks.size(); }
private:
bool mAcceptRequests = true;
bool mShuttingDown = false;
std::deque<std::function<void()>> mTasks;
std::deque<std::function<void()>> mMainTasks;
};
// 对应 ResourceBackgroundQueue:方法把任务包成 packaged_task 交给 WorkQueue
class ResourceBackgroundQueueRepro {
public:
explicit ResourceBackgroundQueueRepro(WorkQueueRepro* wq) : mWq(wq) {}
// 对应 ResourceBackgroundQueue::load(OGRE_THREAD_SUPPORT != 1 分支)
std::future<void> load(const std::shared_ptr<ResourceRepro>& res) {
auto task = std::make_shared<std::packaged_task<void()>>(
[res, this]() {
res->prepare(true);
mWq->addMainThreadTask(
[res]() { res->load(true); res->_fireLoadingComplete(); });
});
mWq->addTask([task]() { (*task)(); });
return task->get_future();
}
// 对应 ResourceBackgroundQueue::prepare:纯后台
std::future<void> prepare(const std::shared_ptr<ResourceRepro>& res) {
auto task = std::make_shared<std::packaged_task<void()>>(
[res]() { res->prepare(true); });
mWq->addTask([task]() { (*task)(); });
return task->get_future();
}
private:
WorkQueueRepro* mWq;
};
} // namespace ogre_repro
int main() {
using namespace ogre_repro;
WorkQueueRepro wq;
ResourceBackgroundQueueRepro rbq(&wq);
// load():后台 prepare + 主线程 load,future 立即可查询
auto res = std::make_shared<ResourceRepro>();
std::future<void> fut = rbq.load(res);
CHECK(!res->isPrepared());
CHECK(!res->isLoaded());
CHECK_EQ(wq.pendingBackground(), size_t(1));
CHECK_EQ(wq.pendingMain(), size_t(0));
CHECK(fut.wait_for(std::chrono::milliseconds(0)) == std::future_status::timeout);
// 后台 worker 跑 packaged_task:prepare 完成,且向主线程派发 load
wq._processNextRequest();
CHECK(res->isPrepared());
CHECK(!res->isLoaded());
CHECK_EQ(wq.pendingBackground(), size_t(0));
CHECK_EQ(wq.pendingMain(), size_t(1));
CHECK(fut.wait_for(std::chrono::milliseconds(0)) == std::future_status::ready);
// 主线程泵:真正的 load 发生,future 已 ready
wq.processMainThreadTasks();
CHECK(res->isLoaded());
CHECK_EQ(wq.pendingMain(), size_t(0));
// 拒绝接受新任务:packaged_task 被静默丢弃,prepare 永不发生
wq.setRequestsAccepted(false);
auto res2 = std::make_shared<ResourceRepro>();
std::future<void> fut2 = rbq.load(res2);
CHECK_EQ(wq.pendingBackground(), size_t(0));
wq._processNextRequest();
CHECK(!res2->isPrepared());
CHECK(!res2->isLoaded());
return lab::report("14-3 多线程渲染");
}
本机实测(Apple clang 16,clang++ -std=c++20):编译通过(-Wall 零警告),断言 15/15 通过。
future 就绪与资源可用
默认线程模式下,future 跟踪后台 packaged task。worker 准备资源并将 load(true) 投递到主线程后,future 就可能就绪。调用方需要等主线程处理加载和完成通知,才能按加载完成使用该资源。
小结
ResourceBackgroundQueue本身单线程无锁,并行化全部收敛在共享WorkQueue。- 每个方法三步曲:
packaged_task包装 →addTask投递 → 返回get_future()。 - 默认配置下
load拆两段:后台prepare、主线程load+_fireLoadingComplete。 - future 在后台段结束即 ready,可能早于主线程的监听回调。
- 任务在关停/拒绝期被静默丢弃时,资源永远停在未准备状态。
阅读导航:上一节:14.2 WorkQueue 与后台加载 · 下一节:15.1 选择渲染后端 。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。