答案：该C++线程池通过管理固定数量的工作线程和任务队列，利用互斥锁与条件变量实现线程同步，使用std::function封装任务并通过lambda实现线程循环处理，析构时安全停止所有线程。
实现一个简单的C++线程池，核心是管理一组可复用的工作线程，避免频繁创建和销毁线程带来的开销。下面是一个基于标准库（std::thread、std::queue、std::mutex、std::condition_variable）的轻量级线程池实现。
线程池基本结构
一个简单线程池通常包含：
- 固定数量的工作线程
- 任务队列（存放待执行的函数对象）
- 互斥锁保护共享数据
- 条件变量用于唤醒等待线程
- 控制线程池是否运行的标志
代码实现
#include <iostream>
#include <vector>
#include <queue>
#include <thread>
#include <functional>
#include <mutex>
#include <condition_variable>
#include <atomic>
class ThreadPool {
public:
explicit ThreadPool(int numThreads) : stop(false) {
for (int i = 0; i < numThreads; ++i) {
workers.emplace_back([this] {
while (true) {
std::function<void()> task;
{
std::unique_lock<std::mutex> lock(queue_mutex);
condition.wait(lock, [this] { return stop || !tasks.empty(); });
if (stop && tasks.empty()) return;
task = std::move(tasks.front());
tasks.pop();
}
task();
}
});
}
}
~ThreadPool() {
{
std::unique_lock<std::mutex> lock(queue_mutex);
stop = true;
}
condition.notify_all();
for (std::thread& worker : workers) {
worker.join();
}
}
// 添加任务，支持任意可调用对象
template<class F>
void enqueue(F&& f) {
{
std::unique_lock<std::mutex> lock(queue_mutex);
tasks.emplace(std::forward<F>(f));
}
condition.notify_one();
}
private:
std::vector<std::thread> workers; // 工作线程
std::queue<std::function<void()>> tasks; // 任务队列
std::mutex queue_mutex; // 保护任务队列
std::condition_variable condition; // 唤醒线程
std::atomic<bool> stop; // 是否停止
};
使用示例
下面是一个简单的测试用法：
int main() {
ThreadPool pool(4); // 创建4个线程的线程池
// 提交10个任务
for (int i = 0; i < 10; ++i) {
pool.enqueue([i] {
std::cout << "Task " << i << " is running on thread "
<< std::this_thread::get_id() << '\n';
std::this_thread::sleep_for(std::chrono::milliseconds(100));
});
}
// 主函数退出前，pool析构会自动等待所有线程完成
return 0;
}
关键点说明
这个实现的关键在于：
立即学习“C++免费学习笔记（深入）”；
- lambda线程函数：每个线程在循环中等待任务，通过条件变量阻塞
- RAII资源管理：析构函数中设置停止标志并join所有线程，确保安全退出
-
通用任务封装：使用
std::function<void()>接收任意可调用对象 -
移动语义：通过
std::forward高效传递任务
