c++ 工具类TaskProcessor 支持同步、异步、延迟任务

如下是测试示例：

void foo2 (){
    std::cout << "foo2" << std::endl;
}

int mainTest() {
    TaskProcessor tp;
    std::cout << "start SyncTask" << std::endl;
    tp.SyncTask(foo2);
    std::cout << "Current thread id: " << tp.GetThreadId() << std::endl;
     测试异步任务
    tp.AsyncTask([](){
        std::cout << "Async task" << std::endl;
    });
     测试延迟执行任务
    tp.DelayTask(500,[](){
        std::cout << "DelayTask" << std::endl;
    });

    tp.AsyncTask([](){
        std::cout << "Async task2" << std::endl;
    });

     等待异步任务完成
//    std::this_thread::sleep_for(std::chrono::milliseconds(200));
     测试同步任务超时
//    tp.SyncTask( []() {
//        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
//        std::cout << "Timeout task" << std::endl;
//    });

     等待任务处理完毕
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));

    std::cout << "------end------"<< std::endl;
    return 0;
}

代码实现

#pragma once
#include 
#include 
#include 
#include 
#include 
#include 
#include 

// 定义一个任务结构体，包含任务名称、任务参数、执行时间、是否超时等信息
struct Task {
    std::string name;               // 任务名称
    std::function<void()> func;     // 任务函数
    std::chrono::system_clock::time_point execute_time;  // 执行时间
    bool is_timeout;                // 是否超时
};

class TaskProcessor {
public:
    TaskProcessor() : is_running_(false), is_stopped_(false) {
        // 启动任务处理线程
        thread_ = std::thread(&TaskProcessor::Run, this);
    }

    ~TaskProcessor() {
        // 停止任务处理线程
        Stop();
        // 打印未执行的任务名称和参数
        while (!tasks_.empty()) {
            auto task = tasks_.front();
            std::cout << "Task \"" << task.name << "\" with parameter \"" << task.func.target_type().name()
                      << "\" not executed" << std::endl;
            tasks_.pop();
        }
    }

    // 添加一个同步执行的任务
    template<typename Func, typename... Args>
    void SyncTask(Func &&func, Args &&... args) {
//        // 创建任务结构体，并将其放入任务队列中
//        Task task = {"SyncTask", std::bind(std::forward(func), std::forward(args)...),
//                     std::chrono::system_clock::now(), false};
//        tasks_.push(task);
//        cv_.notify_one();
//        // 等待任务完成
//        std::unique_lock lock(mutex_);
//        cv_.wait(lock, [&]() {
//            return tasks_.empty();
//        });

        // 创建任务结构体，并将其放入任务队列中
        Task task = {"SyncTask", std::bind(std::forward<Func>(func), std::forward<Args>(args)...),
                     std::chrono::system_clock::now(), false};
        std::unique_lock<std::mutex> lock(mutex_);
        tasks_.push(task);
        cv_.notify_one();
        // 等待任务执行完毕
        cv_.wait(lock, [&]() {
            return task.execute_time <= std::chrono::system_clock::now();
        });
    }

    // 添加一个异步执行的任务
    template<typename Func, typename... Args>
    void AsyncTask(Func &&func, Args &&... args) {
        // 创建任务结构体，并将其放入任务队列中
        Task task = {"AsyncTask", std::bind(std::forward<Func>(func), std::forward<Args>(args)...),
                     std::chrono::system_clock::now(), false};
        tasks_.push(task);
        // 通知任务处理线程
        cv_.notify_one();
    }

    // 添加一个延迟执行的任务
    template<typename Func, typename... Args>
    void DelayTask(int delay_ms, Func &&func, Args &&... args) {
        // 创建任务结构体，并将其放入延迟任务队列中
        Task task = {"DelayTask", std::bind(std::forward<Func>(func), std::forward<Args>(args)...),
                     std::chrono::system_clock::now() + std::chrono::milliseconds(delay_ms), false};
        std::unique_lock<std::mutex> lock(mutex_);
        delay_tasks_.push(task);
        // 通知任务处理线程
        cv_.notify_one();
    }

    // 获取当前线程ID
    std::thread::id GetThreadId() {
        return thread_.get_id();
    }

    // 停止任务处理线程
    void Stop() {
        if (is_running_) {
            is_stopped_ = true;
            cv_.notify_one();
            thread_.join();
            is_running_ = false;
        }
    }

private:
    void Run() {
        is_running_ = true;
        while (true) {
            std::unique_lock<std::mutex> lock(mutex_);
            cv_.wait_until(lock, GetNextTaskTime(), [&]() { return !tasks_.empty() || is_stopped_; });
            // 如果接收到停止信号，则退出循环
            if (is_stopped_) {
                break;
            }
            // 处理所有需要执行的任务
            while (!tasks_.empty() && tasks_.front().execute_time <= std::chrono::system_clock::now()) {
                auto task = tasks_.front();
                tasks_.pop();
                // 执行任务
                try {
                    task.func();
                } catch (...) {
                    // 如果任务执行出错，则标记为超时
                    task.is_timeout = true;
                }
            }
            // 处理所有需要延迟执行的任务
            while (!delay_tasks_.empty() && delay_tasks_.front().execute_time <= std::chrono::system_clock::now()) {
                auto task = delay_tasks_.front();
                delay_tasks_.pop();
                tasks_.push(task);
            }
            // 如果任务队列为空，则通知等待的同步调用
            if (tasks_.empty()) {
                cv_.notify_all();
            }
        }
    }

// 获取下一个任务执行时间
    std::chrono::system_clock::time_point GetNextTaskTime() {
        if (!tasks_.empty()) {
            return tasks_.front().execute_time;
        }
        if (!delay_tasks_.empty()) {
            return delay_tasks_.front().execute_time;
        }
        return std::chrono::system_clock::time_point::max();
    }

    std::thread thread_;                // 任务处理线程
    std::queue<Task> tasks_;            // 任务队列
    std::queue<Task> delay_tasks_;      // 延迟任务队列
    bool is_running_;                   // 任务处理线程是否正在运行
    bool is_stopped_;                   // 是否收到停止信号
    std::mutex mutex_;                  // 互斥锁
    std::condition_variable cv_;        // 条件变量
};

最后，刚熟悉C++开发，如有问题或者建议 欢迎评论交流，感谢