C++中每毫秒调用多模块200+函数日志条目不足，求最优方案

我需要每毫秒调用来自5~10个不同模块的200余个函数以获取数据并写入日志。目前采用循环调用方式，但无法得到预期数量的日志条目。请问最佳实现方式是什么？

以下为我的设计代码片段（非精确实现）：

std::ofstream logStream;
while (stop)
{
    for (int moduleIdx = 0; moduleIdx < moduleSize; moduleIdx++)
    {
        for (int fnIdx = 0; fnIdx < module[moduleIdx].totalFns(); fnIdx++)
        {
            std::string output;
            module[moduleIdx]->fn[fnIdx](output);
            logStream << moduleIdx << "," << fnIdx << "," << output << "\n";
        }
    }
    std::this_thread::sleep_for(1ms);
}
logStream.close();

核心问题分析 #

当前方案的问题在于：200多个函数的执行+日志写入总耗时大概率超过1ms，导致每次循环实际耗时远大于预期；再加上sleep_for(1ms)本身受系统调度限制，实际休眠时间经常远超1ms，最终直接导致日志条目数量不足。

具体优化措施 #

1. 并行化函数调用 #

利用多核CPU并行处理不同模块的函数调用，大幅压缩单轮任务的执行时间：

• 按模块或函数组划分任务，创建与CPU核心数匹配的工作线程。
• 每个线程负责一批函数的调用，收集数据后统一提交到日志队列，避免单线程串行阻塞。

示例思路（伪代码）：

std::vector<std::thread> workers;
std::queue<std::string> logQueue;
std::mutex queueMutex;
std::condition_variable cv;
bool stopFlag = false;

// 独立日志写入线程，避免IO阻塞业务逻辑
std::thread logWriter([&](){
    while(!stopFlag || !logQueue.empty()){
        std::unique_lock<std::mutex> lock(queueMutex);
        cv.wait(lock, [&](){ return !logQueue.empty() || stopFlag; });
        while(!logQueue.empty()){
            logStream << logQueue.front() << "\n";
            logQueue.pop();
        }
        logStream.flush();
    }
});

// 工作线程处理模块函数调用
for(int i=0; i<moduleSize; i++){
    workers.emplace_back([i, &module, &logQueue, &queueMutex, &cv, &stopFlag](){
        while(!stopFlag){
            std::string batch;
            // 批量收集当前模块所有函数的输出
            for(int fnIdx=0; fnIdx<module[i]->totalFns(); fnIdx++){
                std::string output;
                module[i]->fn[fnIdx](output);
                batch += std::to_string(i) + "," + std::to_string(fnIdx) + "," + output + "\n";
            }
            // 提交到日志队列
            std::lock_guard<std::mutex> lock(queueMutex);
            logQueue.push(batch);
            cv.notify_one();
        }
    });
}

// 停止流程：触发所有线程退出并等待结束
stopFlag = true;
cv.notify_all();
for(auto& t : workers) t.join();
logWriter.join();
logStream.close();

2. 用定时触发替代固定sleep #

使用高精度定时器严格控制每毫秒的触发时机，避免累积延迟：

• 记录每次任务的目标触发时间，用sleep_until替代sleep_for，确保每次任务都在指定时间点启动。

示例调整：

auto nextTrigger = std::chrono::steady_clock::now() + std::chrono::milliseconds(1);
while(!stop){
    // 执行当前轮次的函数调用与日志收集
    // ...
    // 休眠到下一个目标时间点
    std::this_thread::sleep_until(nextTrigger);
    nextTrigger += std::chrono::milliseconds(1);
}

3. 优化日志写入性能 #

• 批量写入：收集多组函数输出后一次性写入文件，减少磁盘IO操作次数。
• 关闭同步：给文件流添加logStream.sync_with_stdio(false);和logStream.tie(nullptr);，禁用与C标准IO的同步，提升输出效率。
• 异步IO/内存映射：如果磁盘IO成为瓶颈，可考虑使用内存映射文件或系统级异步IO接口处理日志写入。

4. 函数调用本身的优化 #

• 排查并优化每个函数的执行逻辑，移除冗余操作，压缩单函数耗时。
• 若部分函数非核心需求，可划分优先级，优先保证核心函数的每毫秒执行，非核心函数可适当降低调用频率。

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