实现线程池 ​

面试考点 ​

线程池是并发编程面试的必考题。面试官考察你是否理解线程复用的原理、任务队列的线程安全设计、条件变量的等待/通知机制、packaged_task + future 的异步结果获取,以及线程池的优雅关闭。

核心概念 ​

线程池预先创建固定数量的工作线程,这些线程不断从任务队列中取任务执行。提交任务时不创建新线程,只是把任务放入队列。这避免了频繁创建/销毁线程的开销(线程创建通常需要几十微秒,涉及内核调用和栈分配)。任务队列用 mutex + condition_variable 实现线程安全的生产者-消费者模型。

基本示例 ​

cpp
#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_taskpackaged_task<ReturnType()>把任务和 future 关联
shared_ptr 包装make_sharedstd::function 要求可拷贝
获取 futuretask->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,如何保证优雅关闭,以及条件变量的虚假唤醒处理。