C++ 线程池设计与实现示例
线程池是一种常用的并发编程模式，它可以有效地管理线程资源，提高程序的性能。在多线程程序中，创建和销毁线程的开销较大，而线程池通过复用一定数量的线程来减少这种开销。本文将围绕C++语言，介绍线程池的设计与实现。
线程池的基本原理
线程池的基本原理是维护一个线程队列，当有任务需要执行时，将任务提交给线程池，线程池会从队列中分配一个空闲的线程来执行任务。当线程执行完任务后，它会返回到线程池中等待下一个任务。这样，线程池可以有效地管理线程资源，避免频繁创建和销毁线程。
线程池的设计
1. 线程池类
线程池类负责管理线程的创建、销毁和任务的提交与执行。以下是线程池类的基本结构：
cpp
include
include
include
include
include
include
include
include
class ThreadPool {
public:
ThreadPool(size_t threads) : stop(false) {
for (size_t i = 0; i < threads; ++i) {
workers.emplace_back([this] {
for (;;) {
std::function task;
{
std::unique_lock 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();
}
});
}
}
template
auto enqueue(F&& f, Args&&... args)
-> std::future<#typename std::result_of::type> {
using return_type = typename std::result_of::type;
auto task = std::make_shared< std::packaged_task >(
std::bind(std::forward(f), std::forward(args)...)
);
std::future res = task->get_future();
{
std::unique_lock lock(queue_mutex);
if (stop)
throw std::runtime_error("enqueue on stopped ThreadPool");
tasks.emplace(
}
condition.notify_one();
return res;
}
~ThreadPool() {
{
std::unique_lock lock(queue_mutex);
stop = true;
}
condition.notify_all();
for (std::thread &worker: workers)
worker.join();
}
private:
std::vector workers;
std::queue< std::function > tasks;
std::mutex queue_mutex;
std::condition_variable condition;
bool stop;
};
2. 任务队列
任务队列用于存储待执行的任务。在上述代码中，我们使用了一个`std::queue`来存储任务，每个任务是一个`std::function`对象。
3. 线程管理
线程池中的线程负责从任务队列中获取任务并执行。在上述代码中，我们使用了一个`std::vector`来存储线程对象。
4. 同步机制
为了确保线程池的正确运行，我们需要使用同步机制来保护共享资源。在上述代码中，我们使用了`std::mutex`和`std::condition_variable`来实现同步。
线程池的实现
以下是一个简单的线程池实现示例：
cpp
include
include
include
include
include
include
include
include
class ThreadPool {
public:
ThreadPool(size_t threads) : stop(false) {
for (size_t i = 0; i < threads; ++i) {
workers.emplace_back([this] {
for (;;) {
std::function task;
{
std::unique_lock 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();
}
});
}
}
template
auto enqueue(F&& f, Args&&... args)
-> std::future<#typename std::result_of::type> {
using return_type = typename std::result_of::type;
auto task = std::make_shared< std::packaged_task >(
std::bind(std::forward(f), std::forward(args)...)
);
std::future res = task->get_future();
{
std::unique_lock lock(queue_mutex);
if (stop)
throw std::runtime_error("enqueue on stopped ThreadPool");
tasks.emplace(
}
condition.notify_one();
return res;
}
~ThreadPool() {
{
std::unique_lock lock(queue_mutex);
stop = true;
}
condition.notify_all();
for (std::thread &worker: workers)
worker.join();
}
private:
std::vector workers;
std::queue< std::function > tasks;
std::mutex queue_mutex;
std::condition_variable condition;
bool stop;
};
int main() {
ThreadPool pool(4);
auto future = pool.enqueue([](int x) { return x x; }, 5);
std::cout << "Result: " << future.get() << std::endl;
return 0;
}
在这个示例中，我们创建了一个包含4个线程的线程池，并提交了一个计算平方的任务。任务执行完成后，我们通过`future.get()`获取了结果。
总结
本文介绍了C++语言中线程池的设计与实现。通过使用线程池，我们可以有效地管理线程资源，提高程序的性能。在实际应用中，可以根据需求调整线程池的大小和任务队列的结构，以满足不同的并发需求。
Comments NOTHING