注：该文用于个人学习记录和知识交流，如有不足，欢迎指点。
一、线程池是什么？
- 进程是操作系统进行资源分配的基本单位，线程是操作系统进行CPU调度的基本单位。
- 线程池是维持管理一定数量线程的池式结构：
- 维持就是复用、
- 管理就是控制线程工作和休眠，
- 一定数量是因为CPU核心数有限（线程池过多会增加CPU切换）
总的来说：线程池（Thread Pool）是一种预先创建一组可复用线程的资源管理机制，核心是维护一个线程集合，将任务提交到线程池后，由池中的空闲线程执行，避免频繁创建 / 销毁线程的开销，同时统一管理线程的生命周期
二、线程池解决的问题
异步执行耗时任务（不过度占用核心线程），充分利用多核。
耗时：
- 耗时等待（io）：如落盘操作、向数据库请求数据
- 耗时计算：如加解密运算等
三、线程池是如何实现的呢？
在 C++ 中
可基于以下同步原语实现
std::thread：线程std::mutex：互斥锁std::condition_variable：条件变量
也可使用第三方库（如 Boost.ThreadPool）。
实现模板
- 生产消费模型：任务队列
- 生产者push任务到队列，唤醒一个休眠线程
- 消费者从任务队列里面取任务去执行
- 任务队列里面没有任务的话消费者会陷入休眠（线程阻塞）
问1：为什么采用队列？
- 职责：生产者对应着一个口、消费者对应着另一个口
- 队列的插入和读取O(1) 、 锁占用的时间短 、 锁的使用变得灵活
问2：线程池中的线程数量如何确定
- cpu密集型：
经验值：cpu核心数个线程数量。
最优值：经验值+1、+2比对性能得到- io密集型：
（线程等待时间+cpu运算时间）*cpu核心数/cpu运算时间
经验值：2*cpu核心数个线程数量（一半等待、一半执行）。
最优值：经验值+1、+2 比对性能得到- 性能测试（吞吐量）：每秒执行的任务数量
问3：线程池的设计关键？
关键在于队列的设计和线程数量的管理。
1. 队列的设计
| 队列设计维度 | 对应的线程池类型 | 核心影响 |
|---|---|---|
| 队列边界（有界 / 无界） | 有界任务队列线程池 / 无界队列池 | 决定任务积压时的行为（阻塞 / 拒绝 / 溢出） |
| 队列排序规则 | 普通 FIFO 池 / 优先级线程池 | 决定任务执行的优先级（如 VIP 订单优先） |
| 队列时间属性 | 普通池 / 定时 / 延迟线程池 | 决定任务是否支持延迟 / 周期性执行 |
| 队列数据结构 | 普通队列池 / 批量任务池 | 决定是否支持任务批量提取 / 执行 |
| 队列的数量 | 生产者一个队列、消费者一个队列 | 通过一次队列的交换减少了锁的竞争 |
tips：FIFO (First In, First Out) : 先进先出
举个典型例子：
- 「优先级线程池」和「普通固定线程池」的核心差异，就是队列从
std::queue（FIFO）换成了std::priority_queue（按优先级排序），线程数管理（固定）完全相同； - 「定时线程池」的核心改造也是队列 —— 将普通队列替换为「按执行时间排序的优先级队列」，线程会定时检查队列头部任务是否到执行时间；
- 「有界任务队列线程池」和「无界固定线程池」的唯一差异，就是队列设置了最大容量，队列满时提交任务的线程会阻塞 / 拒绝任务。
2. 线程数量的管理
| 基础线程池类型 | 核心区分依据（线程数量管理） |
|---|---|
| 固定线程池 | 线程数初始化后固定，永不增删 |
| 缓存线程池 | 线程数动态增减（无核心线程，空闲超时销毁） |
| 单线程池 | 线程数固定为 1，任务串行执行 |
四、代码实现：
关键知识点
1. lock_guard与unique_lock
- lock_guard 无法手动释放锁
- unique_lock 可以手动释放锁
2. std::condition_variable not_empty_;
- not_empty_.wait(lock, condi_func）：释放锁，然后休眠，等待唤醒判断条件是否满足 （满足则获取锁，否则继续休眠）
- not_empty_.notify_one()： 唤醒wait中的一个线程
- not_empty_.notify_all() ：唤醒wait中的所有线程，常用于销毁线程池
核心代码：
1. 固定线程池
threadpool.h
#pragma once #include <thread> #include <functional> #include <vector> // #include "blockingqueue.h" //避免循环依赖（头文件扩散）！！！！！，只在源文件中引用 // 前置声明 // blockingqueue 仅仅只能用作指针或引用 template <typename T> class BlockingQueue; class ThreadPool { public: // 初始化线程池 explicit ThreadPool(int threads_num); // 停止线程池 ~ThreadPool(); // 发布任务到线程池 void Post(std::function<void()> task); private: void Worker(); std::unique_ptr<BlockingQueue<std::function<void()>>> task_queue_; // 拷贝构造会报错 --> 防止外部调用拷贝构造 std::vector<std::thread> workers_; };threadpool.cc
#include "blockingqueue.h" #include <memory> #include "threadpool.h" ThreadPool::ThreadPool(int threads_num) { task_queue_ = std::make_unique<BlockingQueue<std::function<void()>>>(); for (size_t i = 0; i < threads_num; ++i) { workers_.emplace_back([this] {Worker();}); } } // 停止线程池 ThreadPool::~ThreadPool() { task_queue_->Cancel(); for(auto &worker : workers_) { if (worker.joinable()) worker.join(); } } void ThreadPool::Post(std::function<void()> task) { task_queue_->Push(task); } void ThreadPool::Worker() { while (true) { std::function<void()> task; if (!task_queue_->Pop(task)) { break; } task(); } }2. 队列的设计
blockingqueue.h
2.1. 单队列
生产者和消费者共用一个队列，意味着锁的竞争频繁
#pragma once #include <condition_variable> #include <functional> #include <queue> #include <mutex> #include <thread> template <typename T> class BlockingQueue { public: BlockingQueue(bool nonblock = false) : nonblock_(nonblock) { } // 入队操作 void Push(const T &value) { std::lock_guard<std::mutex> lock(mutex_); queue_.push(value); not_empty_.notify_one(); // 唤醒 not_empty_.wait(lock, [this]{ return !queue_.empty() || nonblock_; });处的worker } // 正常 pop 弹出元素 // 异常 pop 没有弹出元素 bool Pop(T &value) { std::unique_lock<std::mutex> lock(mutex_); // 1. mutex_.unlock() // 2. queue_empty && !nonblock 线程在 wait 中阻塞 // notify_one notify_all 唤醒线程 // 3. 假设满足条件 mutex_.lock() // 4. 不满足条件 回到 2 not_empty_.wait(lock, [this]{ return !queue_.empty() || nonblock_; }); // 线程休眠 if (queue_.empty()) return false; value = queue_.front(); queue_.pop(); return true; } // 解除阻塞在当前队列的线程 void Cancel() { std::lock_guard<std::mutex> lock(mutex_); nonblock_ = true; not_empty_.notify_all(); } private: bool nonblock_; std::queue<T> queue_; std::mutex mutex_; std::condition_variable not_empty_; };2.2 双队列
生产者一个队列、消费者一个队列
#pragma once #include <condition_variable> #include <functional> #include <queue> #include <mutex> #include <thread> template <typename T> class BlockingQueuePro { public: BlockingQueuePro(bool nonblock = false) : nonblock_(nonblock) {} void Push(const T &value) { std::lock_guard<std::mutex> lock(prod_mutex_); prod_queue_.push(value); not_empty_.notify_one(); } bool Pop(T &value) { std::unique_lock<std::mutex> lock(cons_mutex_); if (cons_queue_.empty() && SwapQueue_() == 0) { return false; } value = cons_queue_.front(); cons_queue_.pop(); return true; } void Cancel() { std::lock_guard<std::mutex> lock(prod_mutex_); nonblock_ = true; not_empty_.notify_all(); } private: int SwapQueue_() { std::unique_lock<std::mutex> lock(prod_mutex_); not_empty_.wait(lock, [this] {return !prod_queue_.empty() || nonblock_; }); std::swap(prod_queue_, cons_queue_); return cons_queue_.size(); } bool nonblock_; std::queue<T> prod_queue_; std::queue<T> cons_queue_; std::mutex prod_mutex_; std::mutex cons_mutex_; std::condition_variable not_empty_; };
