实现线程池
面试考点
线程池是并发编程面试的必考题。面试官考察你是否理解线程复用的原理、任务队列的线程安全设计、条件变量的等待/通知机制、packaged_task + future 的异步结果获取,以及线程池的优雅关闭。
核心概念
线程池预先创建固定数量的工作线程,这些线程不断从任务队列中取任务执行。提交任务时不创建新线程,只是把任务放入队列。这避免了频繁创建/销毁线程的开销(线程创建通常需要几十微秒,涉及内核调用和栈分配)。任务队列用 mutex + condition_variable 实现线程安全的生产者-消费者模型。
基本示例
#include <iostream>
#include <vector>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <future>
#include <functional>
#include <atomic>
#include <memory>
#include <type_traits>
#include <stdexcept>
// ============================
// 线程池实现
// ============================
class ThreadPool {
public:
// 创建线程池,默认线程数为硬件并发数
explicit ThreadPool(size_t num_threads = std::thread::hardware_concurrency()) {
// 创建工作线程
for (size_t i = 0; i < num_threads; i++) {
workers_.emplace_back([this]() {
// 每个工作线程的主循环
while (true) {
std::function<void()> task;
{
// 等待任务或停止信号
std::unique_lock<std::mutex> lock(mutex_);
condition_.wait(lock, [this]() {
return stopped_ || !tasks_.empty();
});
// 停止且队列为空时退出
if (stopped_ && tasks_.empty()) {
return;
}
// 取出一个任务
task = std::move(tasks_.front());
tasks_.pop();
}
// 执行任务(在锁外执行,不阻塞其他线程取任务)
task();
}
});
}
}
// 提交任务,返回 future 获取结果
template<typename F, typename... Args>
auto submit(F&& f, Args&&... args)
-> std::future<std::invoke_result_t<F, Args...>>
{
using ReturnType = std::invoke_result_t<F, Args...>;
// 把任务包装为 packaged_task
// 用 shared_ptr 因为 std::function 要求可拷贝
auto task = std::make_shared<std::packaged_task<ReturnType()>>(
std::bind(std::forward<F>(f), std::forward<Args>(args)...)
);
// 获取 future(在任务入队前获取)
std::future<ReturnType> result = task->get_future();
{
std::lock_guard<std::mutex> lock(mutex_);
// 不允许在停止后提交任务
if (stopped_) {
throw std::runtime_error("向已停止的线程池提交任务");
}
// 包装为 void() 放入队列
tasks_.emplace([task]() { (*task)(); });
}
// 通知一个等待的工作线程
condition_.notify_one();
return result;
}
// 获取线程数
size_t size() const { return workers_.size(); }
// 获取待处理任务数
size_t pending() const {
std::lock_guard<std::mutex> lock(mutex_);
return tasks_.size();
}
// 析构:等待所有任务完成后关闭
~ThreadPool() {
{
std::lock_guard<std::mutex> lock(mutex_);
stopped_ = true;
}
// 唤醒所有等待的工作线程
condition_.notify_all();
// 等待所有线程结束
for (auto& worker : workers_) {
if (worker.joinable()) {
worker.join();
}
}
}
// 禁止拷贝和移动
ThreadPool(const ThreadPool&) = delete;
ThreadPool& operator=(const ThreadPool&) = delete;
ThreadPool(ThreadPool&&) = delete;
ThreadPool& operator=(ThreadPool&&) = delete;
private:
std::vector<std::thread> workers_; // 工作线程
std::queue<std::function<void()>> tasks_; // 任务队列
mutable std::mutex mutex_; // 保护队列和停止标志
std::condition_variable condition_; // 通知工作线程
bool stopped_ = false; // 停止标志
};
// ============================
// 使用示例
// ============================
// 模拟耗时任务
int compute(int x) {
std::this_thread::sleep_for(std::chrono::milliseconds(50));
return x * x;
}
void test_basic() {
std::cout << "--- 基本用法 ---" << std::endl;
ThreadPool pool(4);
std::cout << "线程数: " << pool.size() << std::endl;
// 提交多个任务,收集 future
std::vector<std::future<int>> futures;
for (int i = 0; i < 10; i++) {
futures.push_back(pool.submit(compute, i));
}
// 获取结果
for (int i = 0; i < 10; i++) {
std::cout << i << "^2 = " << futures[i].get() << std::endl;
}
}
void test_different_types() {
std::cout << "\n--- 不同返回类型 ---" << std::endl;
ThreadPool pool(2);
// 返回 int
auto f1 = pool.submit([]() { return 42; });
// 返回 string
auto f2 = pool.submit([]() {
return std::string("hello from pool");
});
// 返回 void
auto f3 = pool.submit([]() {
std::cout << " 无返回值任务执行" << std::endl;
});
std::cout << "int 结果: " << f1.get() << std::endl;
std::cout << "string 结果: " << f2.get() << std::endl;
f3.get(); // 等待 void 任务完成
}
void test_exception() {
std::cout << "\n--- 异常传播 ---" << std::endl;
ThreadPool pool(2);
auto f = pool.submit([]() -> int {
throw std::runtime_error("任务中的异常");
return 0;
});
try {
f.get(); // 异常在 get() 时重新抛出
} catch (const std::exception& e) {
std::cout << "捕获异常: " << e.what() << std::endl;
}
}
void test_concurrent() {
std::cout << "\n--- 并发执行 ---" << std::endl;
ThreadPool pool(4);
std::mutex print_mutex;
std::vector<std::future<void>> futures;
for (int i = 0; i < 8; i++) {
futures.push_back(pool.submit([i, &print_mutex]() {
{
std::lock_guard<std::mutex> lock(print_mutex);
std::cout << " 任务 " << i << " 在线程 "
<< std::this_thread::get_id()
<< " 上执行" << std::endl;
}
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}));
}
// 等待所有任务完成
for (auto& f : futures) {
f.get();
}
std::cout << "所有任务完成" << std::endl;
}
int main() {
test_basic();
test_different_types();
test_exception();
test_concurrent();
return 0;
}线程池的核心组件
| 组件 | 类型 | 作用 |
|---|---|---|
| workers_ | vector<thread> | 固定数量的工作线程 |
| tasks_ | queue<function<void()>> | 待执行的任务队列 |
| mutex_ | mutex | 保护队列和停止标志 |
| condition_ | condition_variable | 通知工作线程有新任务 |
| stopped_ | bool | 停止标志 |
submit 的类型推导流程
| 步骤 | 操作 | 说明 |
|---|---|---|
| 推导返回类型 | invoke_result_t<F, Args...> | 编译期确定任务的返回类型 |
| 包装为 packaged_task | packaged_task<ReturnType()> | 把任务和 future 关联 |
| shared_ptr 包装 | make_shared | std::function 要求可拷贝 |
| 获取 future | task->get_future() | 调用者用此获取结果 |
| 入队 | tasks_.emplace(lambda) | lambda 捕获 shared_ptr |
| 通知 | condition_.notify_one() | 唤醒一个等待的工作线程 |
常见问题
为什么用 shared_ptr 包装 packaged_task?
std::packaged_task 是 move-only 的(不可拷贝),而 std::function 要求其包装的可调用对象可拷贝。用 shared_ptr 包装后,lambda 捕获的是 shared_ptr(可拷贝),间接持有 packaged_task。C++23 的 std::move_only_function 可以避免这个问题。
线程池析构时如何保证所有任务执行完?
析构函数先设置 stopped_ = true,然后 notify_all 唤醒所有工作线程。工作线程的循环条件是"stopped_ 且队列为空才退出",所以会先执行完队列中的剩余任务再退出。join() 等待所有线程结束。
任务中抛出的异常怎么处理?
异常被 packaged_task 捕获并存储在 future 中。调用者调用 future.get() 时异常会被重新抛出。如果没有人调用 get(),异常会在 future 析构时被丢弃。
为什么 condition_.wait 要用谓词?
条件变量可能虚假唤醒(spurious wakeup)。谓词 lambda 在唤醒后再检查一次条件,如果条件不满足会继续等待。这保证了线程只在"有任务"或"需要停止"时才真正醒来。
适用场景
- Web 服务器的请求处理
- 批量文件处理
- 并行计算(矩阵运算、图像处理)
- 后台异步任务
注意事项
- 线程数通常设为 CPU 核心数(CPU 密集型)或更多(I/O 密集型)
- 任务中不要阻塞等待同一线程池中其他任务的结果(会死锁)
- std::function 有类型擦除开销,性能敏感时可用模板替代
- 停止后不应再提交任务
- 工作线程中的异常如果不通过 future 传播,会导致 std::terminate
总结
线程池的核心是 mutex + condition_variable + 任务队列:工作线程在 condition_.wait 上等待,submit 把任务入队后 notify_one 唤醒一个线程。submit 通过 packaged_task + future 实现异步结果获取。面试中要能完整实现 ThreadPool(构造、submit、析构),解释为什么用 shared_ptr 包装 packaged_task,如何保证优雅关闭,以及条件变量的虚假唤醒处理。