如何高效实现带超时的register_callback API？求推荐合适数据结构

你原本用STL map存储定时任务+工作线程轮询的思路，在毫秒级超时场景下确实会因为频繁轮询浪费CPU资源，这里给你推荐最小堆（优先队列）+ 条件变量的组合方案，既能保持任务的有序性，又能彻底解决无效轮询的问题。

核心思路 #

最小堆的堆顶始终是最早要触发的任务，配合条件变量让工作线程只在「有任务到点触发」或「插入了更早的新任务」时被唤醒，完全不需要定时轮询。

具体实现步骤 #

1. 定义任务结构与最小堆 #

C++标准库的std::priority_queue默认是最大堆，我们需要自定义比较器改成最小堆，存储<触发时间戳, 回调函数>的任务：

#include <queue>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <chrono>

// 定时任务结构体
struct TimerTask {
    uint64_t trigger_time; // 触发时间戳（毫秒级）
    std::function<void()> callback;
};

// 自定义比较器，让优先队列成为最小堆（堆顶是最早触发的任务）
struct TaskComparator {
    bool operator()(const TimerTask& a, const TimerTask& b) {
        return a.trigger_time > b.trigger_time;
    }
};

// 全局（或类内）的堆、互斥锁、条件变量
std::priority_queue<TimerTask, std::vector<TimerTask>, TaskComparator> timer_heap;
std::mutex heap_mutex;
std::condition_variable timer_cv;
bool stop_flag = false; // 线程停止标志

2. 工作线程逻辑 #

工作线程不再轮询，而是通过条件变量等待，要么等到任务触发时间，要么被新插入的任务唤醒：

uint64_t get_current_time_ms() {
    return std::chrono::duration_cast<std::chrono::milliseconds>(
        std::chrono::system_clock::now().time_since_epoch()
    ).count();
}

void timer_worker() {
    while (!stop_flag) {
        std::unique_lock<std::mutex> lock(heap_mutex);
        
        // 等待直到堆不为空或收到停止信号
        timer_cv.wait(lock, []{ return !timer_heap.empty() || stop_flag; });
        
        if (stop_flag && timer_heap.empty()) break;
        if (timer_heap.empty()) continue;
        
        auto now = get_current_time_ms();
        auto& top_task = timer_heap.top();
        
        if (top_task.trigger_time <= now) {
            // 取出回调，先解锁再执行（避免阻塞其他任务操作）
            auto callback = top_task.callback;
            timer_heap.pop();
            lock.unlock();
            
            callback();
        } else {
            // 计算需要等待的时长，等待期间若有新任务插入会被唤醒
            auto wait_ms = top_task.trigger_time - now;
            timer_cv.wait_for(lock, std::chrono::milliseconds(wait_ms));
        }
    }
}

3. 实现register_callback API #

注册任务时，计算触发时间戳插入堆，然后唤醒工作线程（防止插入了比堆顶更早的任务）：

void register_callback(std::function<void()> callback_func, uint64_t timeout) {
    uint64_t trigger_time = get_current_time_ms() + timeout;
    
    std::lock_guard<std::mutex> lock(heap_mutex);
    timer_heap.push({trigger_time, callback_func});
    
    // 唤醒工作线程，重新检查堆顶任务的等待时长
    timer_cv.notify_one();
}

方案优势 #

• 无无效轮询：工作线程大部分时间处于休眠状态，只有必要时才被唤醒，CPU占用极低
• 高效的任务管理：堆的插入、删除操作都是O(logn)时间复杂度，和STL map相当，但配合条件变量的唤醒机制比轮询map高效得多
• 实时响应新任务：如果插入了比当前堆顶更早的任务，工作线程会被立即唤醒，调整等待时长，不会错过触发时间

注意事项 #

• 回调函数的执行时间不宜过长，如果回调耗时久，建议把回调放到单独的线程池执行，避免阻塞定时任务的处理
• 时间戳要保证精度统一，比如全程用毫秒级时间，避免计算误差
• 要处理工作线程的优雅退出逻辑，比如通过stop_flag配合条件变量唤醒线程

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