### C++
线程池的实现与使用
#### 1.
线程池的概念
线程池是一种用于管理多个任务并行执行的技术。它通过预先创建一组工作线程来处理提交的任务，从而减少频繁创建和销毁线程带来的开销[^2]。
线程池的核心目标是提高程序性能，尤其是在高并发场景下。
---
#### 2. 基于C++11的
线程池设计
现代C++提供了丰富的多线程支持工具，例如`std::thread`, `std::mutex`, `std::condition_variable`等。这些工具使得我们可以高效地实现一个功能完善的
线程池[^3]。
以下是
线程池的主要组成部分：
- **任务队列**：存储待执行的任务。
- **工作线程集合**：负责从任务队列中取出任务并执行。
- **同步机制**：确保线程安全访问共享资源（如任务队列）。
- **停止标志**：控制
线程池的生命周期。
---
#### 3.
线程池的关键技术点
为了更好地理解和实现
线程池，我们需要掌握以下几个关键技术点：
##### (1) 使用`std::function`封装任务
`std::function`可以用来封装任意可调用对象（如函数指针、lambda表达式、绑定器等），这使得我们的
线程池能够接受多种形式的任务。
```cpp
using Task = std::function<void()>;
```
##### (2) 条件变量与互斥锁
条件变量(`std::condition_variable`)和互斥锁(`std::mutex`)共同协作，确保线程等待有任务可用时不会浪费CPU资源[^2]。
```cpp
std::queue<Task> tasks;
std::mutex queue_mutex;
std::condition_variable condition;
bool stop = false;
```
##### (3) 工作线程循环
每个工作线程在一个无限循环中运行，直到收到停止信号为止。每次迭代都会尝试从任务队列中取任务并执行[^4]。
```cpp
void WorkerLoop() {
while (!stop) {
Task task;
{
std::unique_lock<std::mutex> lock(queue_mutex);
condition.wait(lock, [this]() { return !tasks.empty() || stop; });
if (stop && tasks.empty()) break;
task = std::move(tasks.front());
tasks.pop();
}
task();
}
}
```
---
#### 4. 完整的
线程池实现
下面是一个简单的
线程池实现示例，涵盖了初始化、启动、提交任务以及关闭等功能[^4]。
```cpp
#include <iostream>
#include <vector>
#include <thread>
#include <queue>
#include <functional>
#include <memory>
#include <future>
#include <stdexcept>
class ThreadPool {
public:
explicit ThreadPool(size_t threads_num) : stop(false) {
for (size_t i = 0; i < threads_num; ++i) {
workers.emplace_back([this] {
this->WorkerLoop();
});
}
}
template<class F, class... Args>
auto exec(F&& f, Args&&... args) -> std::future<decltype(f(args...))> {
using ReturnType = decltype(f(args...));
auto task = std::make_shared<std::packaged_task<ReturnType()>>(std::bind(std::forward<F>(f), std::forward<Args>(args)...));
std::future<ReturnType> res = task->get_future();
{
std::lock_guard<std::mutex> lock(queue_mutex);
if (stop) throw std::runtime_error("Thread pool is stopped");
tasks.emplace([task]() { (*task)(); });
}
condition.notify_one();
return res;
}
~ThreadPool() {
{
std::unique_lock<std::mutex> lock(queue_mutex);
stop = true;
}
condition.notify_all();
for (auto& worker : workers) {
if (worker.joinable()) worker.join();
}
}
private:
void WorkerLoop() {
while (!stop) {
Task task;
{
std::unique_lock<std::mutex> lock(queue_mutex);
condition.wait(lock, [this]() { return !tasks.empty() || stop; });
if (stop && tasks.empty()) break;
task = std::move(tasks.front());
tasks.pop();
}
task();
}
}
using Task = std::function<void()>;
std::vector<std::thread> workers;
std::queue<Task> tasks;
std::mutex queue_mutex;
std::condition_variable condition;
bool stop;
};
// 测试代码
int main() {
ThreadPool pool(4);
auto future1 = pool.exec([](int a) { return a * 2; }, 5);
auto future2 = pool.exec([](double b) { return b / 3.0; }, 9.0);
std::cout << "Result of first task: " << future1.get() << std::endl;
std::cout << "Result of second task: " << future2.get() << std::endl;
return 0;
}
```
---
#### 5. 如何使用
线程池
要使用上述
线程池类，只需实例化一个`ThreadPool`对象，并通过其成员函数`exec()`提交任务即可。该方法返回一个`std::future`对象，允许我们在主线程中异步获取任务的结果[^4]。
---
这段摘要是对原始内容的一个概括，包含了核心信息，同时确保了长度在规定的范围内。
扫一扫
735
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
