多线程日志函数优化咨询：解决Sleep批量输出与condition_variable频繁唤醒的CPU占用矛盾

问题描述 #

我正在实现一个多线程日志函数，核心代码如下：

namespace { // Anonymous namespace instead of static functions.
std::mutex log_mutex;
void Background() {
    while(IsAlive){
        std::queue<std::string> log_records;
        { // Exchange data for minimizing lock time.
            std::unique_lock lock(log_mutex);
            logs.swap(log_records);
        }
        if (log_records.empty()) {
            Sleep(200);
            continue;
        }
        while(!log_records.empty()){
            ShowLog(log_records.front());
            log_records.pop();
        }
    }
}
void Log(std::string log){
    std::unique_lock lock(log_mutex);
    logs.push(std::move(log));
}
}

目前遇到的困境是：

• 用Sleep(200)避免空循环高CPU，但会导致日志批量输出延迟明显；
• 换成condition_variable后，短时间大量Log调用会频繁唤醒后台线程，反而让CPU占用更高。

想请教在每秒大量Log调用的场景下，怎么平衡CPU占用和日志输出的实时性？

解决方案 #

我之前也处理过类似的高并发日志场景，给你几个实用的优化思路：

1. 带超时的条件变量 + 批量输出 #

这是最基础且有效的优化方案，核心是让后台线程要么被新日志唤醒，要么超时自动唤醒，既避免空循环的CPU浪费，又能减少频繁唤醒的次数。

修改后的代码示例：

namespace {
std::mutex log_mutex;
std::condition_variable log_cv;
std::queue<std::string> logs;
constexpr auto MAX_WAIT_TIME = std::chrono::milliseconds(50); // 可根据需求调整超时时间

void Background() {
    while(IsAlive){
        std::queue<std::string> log_records;
        {
            std::unique_lock lock(log_mutex);
            // 等待直到有日志、超时，或者收到退出信号
            log_cv.wait_for(lock, MAX_WAIT_TIME, []{ return !logs.empty() || !IsAlive; });
            
            if (!IsAlive) break; // 触发退出信号时直接结束线程
            
            logs.swap(log_records); // 交换数据，最小化锁持有时间
        }
        
        if (!log_records.empty()) {
            // 批量处理日志
            while(!log_records.empty()){
                ShowLog(log_records.front());
                log_records.pop();
            }
        }
    }
}

void Log(std::string log){
    std::unique_lock lock(log_mutex);
    logs.push(std::move(log));
    // 单后台线程场景用notify_one即可，避免不必要的唤醒
    log_cv.notify_one();
}
}

为什么有效？

• 无日志时线程进入休眠，不会空循环消耗CPU；
• 短时间大量日志到来时，后台线程被唤醒一次就能处理一批日志（多个notify_one会在锁释放后合并，减少唤醒次数）；
• 超时时间可灵活调整，比如设为50ms，既保证日志不会延迟太久，又不会过于频繁唤醒线程。

2. 限制唤醒频率（节流） #

如果日志量极大（比如每秒数万条），即使notify_one也可能导致线程频繁唤醒，这时候可以给通知加个“节流”机制：只有距离上次唤醒超过一定间隔时才发送通知，让后台线程一次性处理更多日志。

示例代码片段（在Log函数中添加节流逻辑）：

namespace {
// ... 其他变量保持不变
constexpr auto MIN_NOTIFY_INTERVAL = std::chrono::milliseconds(10); // 最小通知间隔
std::chrono::steady_clock::time_point last_notify_time;

void Log(std::string log){
    std::unique_lock lock(log_mutex);
    logs.push(std::move(log));
    
    auto now = std::chrono::steady_clock::now();
    // 只有当距离上次通知超过设定间隔时，才触发唤醒
    if (now - last_notify_time > MIN_NOTIFY_INTERVAL) {
        log_cv.notify_one();
        last_notify_time = now;
    }
}
}

这种方式能有效减少高频日志下的线程唤醒次数，降低CPU占用。

3. 固定批量大小触发 #

还可以结合“批量阈值”：当队列中的日志数量达到某个设定值（比如100条）时再唤醒线程，否则等超时触发。这样既保证小量日志的实时性（超时触发），又保证大量日志的批量处理（数量阈值触发）。

修改后的关键代码：

// Background函数中的等待条件
log_cv.wait_for(lock, MAX_WAIT_TIME, []{ 
    return logs.size() >= 100 || !logs.empty() || !IsAlive; 
});

// Log函数中的通知逻辑
void Log(std::string log){
    std::unique_lock lock(log_mutex);
    logs.push(std::move(log));
    // 达到批量阈值时触发唤醒
    if (logs.size() >= 100) {
        log_cv.notify_one();
    }
}

总结 #

优先尝试带超时的条件变量方案，这是解决这类问题的标准做法；如果日志量极大，再叠加节流或批量大小触发机制进一步优化。另外要注意，如果ShowLog是IO密集型操作（比如写文件、控制台输出），建议给IO操作也加上缓冲，比如攒够一定量再写入，能进一步降低后台线程的负载。

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