C++20：事件线程向持续运行线程非阻塞传数据的最优方案

问题背景 #

我正在开展一个科研项目，需在Windows窗口以30fps帧率显示图像序列。最初使用GLFW，但发现拖拽窗口标题栏或按住右下角调整窗口大小时，窗口内容无法刷新（因Windows的模态特性）。由于项目限制不能使用GLFW回调捕获事件，需采用Windows原生API，我计划将事件捕获逻辑放在主线程并推入队列，由负责图像处理与渲染的线程每1/30秒一次取出并处理所有事件，再执行图像渲染。

我尝试了三种实现方案：

• 基于std::mutex保护std::queue，渲染线程每次循环都加锁检查队列；
• 引入std::condition_variable优化，避免空队列时的无效锁操作，但存在重复sleep_until的疑问；
• 适配生产者消费者模型，但标准模型无法满足渲染线程每周期清空所有事件的需求，进而尝试了固定大小数组结合原子变量的实现，但该方案队列大小固定，灵活性不足。

现请教以下问题：

1. 初始mutex方案是否存在问题？
2. condition_variable方案中重复sleep_until是否冗余？
3. 固定大小队列的实现是否有潜在问题？
4. 针对我的需求，是否有更高效、优雅且健壮的C++20实现方案？

解答 #

1. 初始mutex方案的问题 #

该方案功能可行但效率低下。渲染线程每33ms左右就要加锁检查队列，即便队列空也会执行锁操作，频繁的锁竞争会带来不必要的上下文切换开销。此外，若主线程在渲染线程解锁后才推入事件，事件要等到下一个33ms周期才能被处理，会产生明显的响应延迟。

2. condition_variable方案中sleep_until是否冗余 #

不冗余，但需注意正确用法。正确的实现是：渲染线程先计算下一次渲染的时间点，调用cv.wait_until(lock, wake_time)而非先sleep再wait。这样能同时处理两种场景：

• 若主线程在wake_time前推入事件，cv.notify_one()会立即唤醒渲染线程，提前处理事件并渲染；
• 若无事件，线程会自动休眠到wake_time，严格保证30fps的帧率稳定性。
  若先sleep再wait，反而会导致事件延迟——哪怕有事件进来，也要等sleep结束才能处理。

3. 固定大小队列的潜在问题 #

最大风险是队列溢出：短时间内事件量超过数组固定大小的话，主线程要么丢事件（导致窗口响应异常），要么阻塞（卡住整个主线程消息循环，程序假死）。另外，固定大小无法适配事件量波动场景，比如窗口resize时会连续产生多个WM_SIZE事件，一旦超出队列容量就会出问题。

4. C++20下的更优实现方案 #

推荐结合std::jthread、std::condition_variable和std::deque实现带定时唤醒的批量事件队列，核心逻辑如下：

• 主线程负责Windows消息循环，将捕获的消息转为自定义事件推入线程安全队列；
• 渲染线程用std::chrono计算每帧目标时间，通过cv.wait_until等待事件或到点唤醒；
• 每次唤醒后，批量取出队列中所有事件（转移到局部队列减少锁持有时间），处理完成后执行渲染，保证每帧至少渲染一次，同时不积压事件。

核心代码示例（简化版）

#include <chrono>
#include <deque>
#include <mutex>
#include <condition_variable>
#include <jthread>
#include <windows.h>

// 自定义窗口事件结构体
struct WindowEvent {
    UINT msg;
    WPARAM wParam;
    LPARAM lParam;
};

class ThreadSafeEventQueue {
private:
    std::mutex mtx;
    std::condition_variable cv;
    std::deque<WindowEvent> event_queue;
    bool stop_flag = false;

public:
    // 推入单个事件
    void push_event(WindowEvent evt) {
        std::lock_guard<std::mutex> lock(mtx);
        event_queue.push_back(std::move(evt));
        cv.notify_one();
    }

    // 批量取出所有事件，或等待到指定时间
    std::deque<WindowEvent> pop_all_events_until(std::chrono::steady_clock::time_point wake_time) {
        std::unique_lock<std::mutex> lock(mtx);
        // 等待条件：有事件/线程停止/到唤醒时间
        cv.wait_until(lock, wake_time, [this]() {
            return !event_queue.empty() || stop_flag;
        });

        std::deque<WindowEvent> result;
        if (!stop_flag) {
            // 转移所有事件到局部队列，释放锁
            result.swap(event_queue);
        }
        return result;
    }

    // 请求线程停止
    void request_stop() {
        std::lock_guard<std::mutex> lock(mtx);
        stop_flag = true;
        cv.notify_one();
    }
};

// 渲染线程逻辑
void render_loop(ThreadSafeEventQueue& event_queue) {
    using namespace std::chrono;
    constexpr auto frame_interval = 1s / 30;
    auto next_render_time = steady_clock::now() + frame_interval;

    while (true) {
        // 获取所有待处理事件
        auto events = event_queue.pop_all_events_until(next_render_time);

        // 批量处理事件
        for (const auto& evt : events) {
            switch (evt.msg) {
                case WM_SIZE:
                    // 处理窗口大小变更，比如调整渲染缓冲区尺寸
                    break;
                case WM_PAINT:
                    // 标记需要重绘（实际渲染在统一步骤执行）
                    break;
                // 其他事件处理逻辑
            }
        }

        // 执行图像渲染（此处替换为你的渲染代码）
        // render_current_frame();

        // 更新下一次渲染时间，修正时间漂移
        next_render_time += frame_interval;
        if (next_render_time < steady_clock::now()) {
            next_render_time = steady_clock::now() + frame_interval;
        }
    }
}

// 主线程WinMain入口
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd) {
    // 窗口创建、注册等初始化操作（省略）
    HWND hwnd = CreateWindowEx(...);

    ThreadSafeEventQueue event_queue;
    // 启动渲染线程，std::jthread自动管理生命周期
    std::jthread render_thread(render_loop, std::ref(event_queue));

    MSG msg;
    // 主线程消息循环
    while (GetMessage(&msg, nullptr, 0, 0)) {
        // 将系统消息转为自定义事件推入队列
        event_queue.push_event({msg.message, msg.wParam, msg.lParam});
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    // 请求渲染线程停止
    event_queue.request_stop();
    return static_cast<int>(msg.wParam);
}

该方案的优势：

• std::deque自动扩容，避免固定队列的溢出问题；
• condition_variable结合wait_until，兼顾帧率稳定性和事件响应及时性；
• 批量取事件减少锁持有时间，提升并发效率；
• std::jthread自动处理线程join，避免资源泄漏；
• 时间漂移修正，防止渲染耗时过长导致帧率下滑。

内容的提问来源于stack exchange，提问作者user18490