第8章线程池（Thread Pool）

课程目录第8章线程池（Thread Pool）

8、线程池（Thread Pool）：线程池的设计原理、C++实现一个简单的线程池、任务队列与工作线程

线程池这个东西，说白了就是「提前招一批工人，有活就干，没活就等着」。我刚开始做并发编程时，总觉得每次来任务就 new 一个线程挺爽的，直到有一次线上服务被大量短任务打垮——创建线程的开销比任务本身还大，系统直接卡死。嗯，从那以后，线程池就成了我工具箱里的常客。

为什么需要线程池？

你想想看，每次创建线程都要做这些事情：分配栈空间、初始化线程控制块、加入调度队列……这些操作都是有成本的。如果任务本身只执行几微秒，那创建线程的时间可能比执行任务还长。更糟糕的是，无限制地创建线程会导致系统资源耗尽，甚至触发 OOM。

线程池的核心思想就三个字：复用。提前创建好一批线程，让它们循环等待任务。任务来了就派一个空闲线程去执行，执行完线程不销毁，继续等下一个任务。这样既省去了频繁创建销毁的开销，又能控制并发数量，防止系统过载。

线程池的三大好处：

降低开销：避免频繁创建/销毁线程
控制并发：限制同时运行的线程数量
任务管理：支持排队、优先级、超时等策略

线程池的设计原理

一个典型的线程池包含三个核心组件：

任务队列：存放待执行的任务，通常是线程安全的队列
工作线程：一组预先创建的线程，不断从队列取任务执行
线程管理器：负责线程的创建、销毁、动态调整

工作流程其实很简单：

外部提交任务到任务队列
空闲的工作线程从队列中取出任务
线程执行任务，执行完后继续等待下一个任务
如果队列为空，线程进入等待状态（避免忙等浪费 CPU）

这里有个关键点：任务队列必须是线程安全的。多个工作线程同时取任务，外部也可能同时提交任务，如果没有合适的同步机制，数据竞争就会找上门来。

我的经验：任务队列用 std::queue 配合 std::mutex 和 std::condition_variable 是最常见的做法。条件变量负责「有任务时通知线程醒来，没任务时让线程休眠」，比轮询高效得多。

用 SVG 画一张线程池结构图

先上一张图，让你对整体结构有个直观印象：

C++ 实现一个简单的线程池

好了，理论说完了，咱们直接上代码。我会实现一个最基础的线程池，包含任务队列、工作线程和基本的生命周期管理。

#include <vector>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <future>
#include <memory>
#include <type_traits>

class ThreadPool {
public:
    // 构造函数：启动 num_threads 个工作线程
    explicit ThreadPool(size_t num_threads)
        : stop_(false) {
        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(this->queue_mutex_);
                        // 等待条件：有任务 或 线程池停止
                        this->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();  // 执行任务
                }
            });
        }
    }

    // 析构函数：停止所有线程
    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex_);
            stop_ = true;
        }
        condition_.notify_all();  // 唤醒所有线程，让它们退出
        for (std::thread &worker : workers_) {
            if (worker.joinable()) {
                worker.join();
            }
        }
    }

    // 提交任务，返回 std::future 获取结果
    template<class F, class... Args>
    auto enqueue(F&& f, Args&&... args)
        -> std::future<typename std::result_of<F(Args...)>::type> {
        using return_type = typename std::result_of<F(Args...)>::type;

        auto task = std::make_shared<std::packaged_task<return_type()>>(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );

        std::future<return_type> result = task->get_future();
        {
            std::unique_lock<std::mutex> lock(queue_mutex_);
            if (stop_) {
                throw std::runtime_error("enqueue on stopped ThreadPool");
            }
            tasks_.emplace([task]() { (*task)(); });
        }
        condition_.notify_one();  // 通知一个空闲线程来取任务
        return result;
    }

private:
    std::vector<std::thread> workers_;          // 工作线程
    std::queue<std::function<void()>> tasks_;   // 任务队列
    std::mutex queue_mutex_;                    // 队列互斥锁
    std::condition_variable condition_;         // 条件变量
    bool stop_;                                 // 停止标志
};

注意：上面的代码中，析构函数先设置 stop_ = true，然后 notify_all()。这里有个细节：必须先释放锁再 notify，否则唤醒的线程可能因为拿不到锁而继续等待。我曾经在这个顺序上踩过坑，导致线程池无法正常退出。

任务队列的设计要点

任务队列是线程池的「心脏」，它的设计直接影响性能和安全性。我总结几个关键点：

设计要点	说明	我的建议
线程安全	多线程同时 push/pop 必须加锁	用 std::mutex + std::condition_variable
任务类型	支持任意可调用对象	用 std::function<void()> 包装
任务优先级	高优先级任务先执行	用优先队列 std::priority_queue
任务超时	任务等待太久自动丢弃	加时间戳，定期清理
队列大小限制	防止内存无限增长	设置最大容量，满时阻塞或拒绝

在实际项目中，我通常还会给任务队列加上「任务窃取」机制——空闲线程可以从其他线程的队列尾部偷任务，这样能更好地平衡负载。不过对于入门来说，上面的基础实现已经够用了。

工作线程的生命周期

工作线程的行为模式可以概括为：

启动：构造函数中创建线程，每个线程进入无限循环
等待：队列为空时，线程在条件变量上等待
执行：被唤醒后，从队列取出任务并执行
退出：析构函数设置 stop_ 标志，通知所有线程退出

这里有个容易被忽略的问题：线程退出时，正在执行的任务怎么办？如果直接设置 stop_ 并 notify_all，正在执行任务的线程不会立即响应——它还在 task() 里面呢。等它执行完，下一次循环检查 stop_ 时才会退出。所以，线程池的停止是优雅的，不会粗暴地中断正在执行的任务。

避坑指南：我曾经在项目里遇到过一个 bug——线程池析构时，某个线程正在执行一个死循环任务，导致析构函数永远卡在 join() 上。后来我加了一个「超时强制退出」机制：给每个任务设置最大执行时间，超时后通过 std::async 配合 std::future 的 wait_for 来检测。虽然不完美，但至少不会让整个程序卡死。

使用示例

来看看怎么用这个线程池：

#include <iostream>

int main() {
    // 创建 4 个工作线程的线程池
    ThreadPool pool(4);

    // 提交多个任务
    auto result1 = pool.enqueue([](int a, int b) {
        return a + b;
    }, 10, 20);

    auto result2 = pool.enqueue([](int a, int b) {
        return a * b;
    }, 5, 6);

    // 获取结果（会阻塞直到任务完成）
    std::cout << "10 + 20 = " << result1.get() << std::endl;
    std::cout << "5 * 6 = " << result2.get() << std::endl;

    // 提交无返回值的任务
    pool.enqueue([] {
        std::cout << "Hello from thread pool!" << std::endl;
    });

    // 线程池析构时会自动等待所有任务完成
    return 0;
}

输出结果：

10 + 20 = 30
5 * 6 = 30
Hello from thread pool!

线程池的进阶话题

上面这个实现虽然能用，但离工业级还差得远。在实际项目中，我还会考虑这些：

动态调整线程数：根据任务队列长度和系统负载，自动增加或减少工作线程
任务优先级：用优先队列替代普通队列，紧急任务插队执行
任务窃取：每个线程有自己的任务队列，空闲线程从其他线程偷任务
异常处理：任务抛出的异常不能杀死工作线程，要捕获并传递给调用方
性能监控：统计任务执行时间、队列长度、线程利用率等指标

我记得有一次做后台服务优化，发现线程池的锁竞争非常严重——所有线程都在抢同一个队列的锁。后来改成每个线程一个独立队列，配合任务窃取，吞吐量直接翻了一倍。所以说，没有银弹，具体怎么设计还得看你的业务场景。

好了，线程池的原理和实现就聊到这里。代码虽然简单，但核心思想都在里面了。你可以在它的基础上加各种花哨的功能，但别忘了——线程池的本质就是「复用」和「控制」，把这两点做好，其他都是锦上添花。

📚 课程目录

8、线程池（Thread Pool）：线程池的设计原理、C++实现一个简单的线程池、任务队列与工作线程

为什么需要线程池？

线程池的设计原理

用 SVG 画一张线程池结构图

C++ 实现一个简单的线程池

任务队列的设计要点

工作线程的生命周期

使用示例

线程池的进阶话题