线程池概述-CSDN博客

本文链接：https://blog.csdn.net/weixin_52734695/article/details/141325281

为什么使用线程池？

性能提升：频繁创建和销毁线程会导致性能损耗。线程池通过复用现有线程减少了这种开销。
资源管理：系统资源是有限的，线程池通过限制线程的数量，避免了资源的过度消耗。
简化管理：集中管理线程，便于调度和监控线程的运行状态。

线程池的基本概念

线程池大小：线程池中线程的数量，通常根据应用的需求和系统的资源来设置。
任务队列：待执行的任务队列。当线程忙碌时，任务会被放入队列中等待执行。
工作线程：线程池中的线程，负责从任务队列中取出任务并执行。

线程池的实现原理

初始化：创建一个固定数量的工作线程，准备接受任务。
任务提交：将任务放入任务队列中，工作线程从队列中取出任务并执行。
任务执行：工作线程处理任务，执行任务的代码。
销毁线程池：在不再需要线程池时，合理关闭并清理资源。

线程池的简单实现

下面是一个C++中简单的线程池实现例子：

#include <iostream>
#include <vector>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <future>

class ThreadPool {
public:
    ThreadPool(size_t threads);
    ~ThreadPool();

    template<class F, class... Args>
    auto enqueue(F&& f, Args&&... args) 
        -> std::future<typename std::result_of<F(Args...)>::type>;

private:
    // 需要保持追踪线程的退出
    std::vector<std::thread> workers;
    // 任务队列
    std::queue<std::function<void()>> tasks;

    // 同步
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
};

// 构造函数启动一定数量的工作线程
ThreadPool::ThreadPool(size_t threads)
    : stop(false)
{
    for(size_t i = 0; i < threads; ++i)
        workers.emplace_back(
            [this]
            {
                for(;;)
                {
                    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();
                }
            }
        );
}

// 添加新任务到任务队列
template<class F, class... Args>
auto ThreadPool::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> res = task->get_future();
    {
        std::unique_lock<std::mutex> lock(queue_mutex);

        // don't allow enqueueing after stopping the pool
        if(stop)
            throw std::runtime_error("enqueue on stopped ThreadPool");

        tasks.emplace([task](){ (*task)(); });
    }
    condition.notify_one();
    return res;
}

// 析构函数中停止所有线程
ThreadPool::~ThreadPool()
{
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        stop = true;
    }
    condition.notify_all();
    for(std::thread &worker: workers)
        worker.join();
}

int main() {
    ThreadPool pool(4);

    auto result1 = pool.enqueue([](int answer) { return answer; }, 42);
    auto result2 = pool.enqueue([](int a, int b) { return a + b; }, 10, 20);

    std::cout << "Result1: " << result1.get() << std::endl;
    std::cout << "Result2: " << result2.get() << std::endl;

    return 0;
}