explicit ThreadPool(size_t threadNum) : stop(false) {

for (int i = 0; i < threadNum; i ++) {

workers.emplace_back([this]() {

while(1) {

std::function<void()> task;

{

std::unique_lock<std::mutex> lock(queue_mutex);

condition.wait(lock, [this]() {

return this->stop || !this->tasks.empty();

});

// 如果线程池已停止且任务队列为空，则线程退出

if (this->stop && this->tasks.empty()) {

return;

}

// 从队列中取出一个任务

task = std::move(this->tasks.front());

this->tasks.pop();

}

// 执行任务（注意：在锁外执行，避免长时间持有锁）

task();

}

});

}

}

template<class F, class... Args>

auto submit(F&& f, Args&&... args)

-> std::future<typename std::result_of<F(Args...)>::type> {

// 推导任务的返回类型

using result_type = typename std::result_of<F(Args...)>::type;

// 将任务和参数打包成一个无参数的可调用对象

// 使用std::packaged_task来获取异步结果

auto task = std::make_shared<std::packaged_task<result_type()>> (

std::bind(std::forward<F>(f), std::forward<Args>(args)...)

);

std::future<result_type> res = task->get_future();

{

std::lock_guard<std::mutex> lock(queue_mutex);

// 如果线程池已停止，不允许提交新任务

if (stop) {

throw std::runtime_error("submit on stopped ThreadPool");

}

// 将任务加入队列

tasks.emplace([task](){ (*task)(); });

}

// 通知一个等待的工作线程

condition.notify_one();

return res;

}

// 优雅关闭：等待所有已提交的任务完成

void shutdown() {

stop = true;

condition.notify_all();

// 等待所有工作线程结束

for(std::thread &worker : workers)

worker.join();

workers.clear();

}

// 立即关闭：不等待队列中剩余的任务

void shutdown_now() {

{

std::unique_lock<std::mutex> lock(queue_mutex);

stop = true;

// 清空任务队列

while(!tasks.empty()) tasks.pop();

}

condition.notify_all();

for(std::thread &worker : workers)

worker.join();

workers.clear();

}

// 获取等待执行的任务数量

size_t pending_tasks() const {

std::unique_lock<std::mutex> lock(queue_mutex);

return tasks.size();

}

// 析构函数自动关闭线程池

~ThreadPool() {

if(!stop) {

shutdown();

}

}

// 工作线程组

std::vector<std::thread> workers;

// 任务队列

std::queue<std::function<void()>> tasks;

// 同步原语

mutable std::mutex queue_mutex;

std::condition_variable condition;

// 停止标志

std::atomic<bool> stop;