如下是测试示例:
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 <iostream>
#include <queue>
#include <chrono>
#include <thread>
#include <functional>
#include <mutex>
#include <condition_variable>
// 定义一个任务结构体,包含任务名称、任务参数、执行时间、是否超时等信息
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>(func), std::forward<Args>(args)...),
// std::chrono::system_clock::now(), false};
// tasks_.push(task);
// cv_.notify_one();
// // 等待任务完成
// std::unique_lock<std::mutex> 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++开发,如有问题或者建议 欢迎评论交流,感谢