《线程池详细讲解及应用》

简介

线程池是一种多线程技术，用于有效地利用计算机的多核处理器，提高程序的性能和效率。线程池可以管理和调度多个线程，将任务分配给空闲的线程执行，从而避免了重复创建和销毁线程的开销，并且能够避免线程数量过多导致的系统资源浪费。
线程池由线程池管理器、工作线程和任务队列组成，通过管理器的控制，将多个任务分配给工作线程处理，从而达到提高程序的性能和效率的目的。
CPP 线程池是实现多线程编程的一种高级技术，可以在高并发的环境下提高程序的运行效率。

考虑

如果所有任务都是无限执行的话，线程池中的有限线程数量就会导致任务无法得到及时处理，从而降低程序的响应速度和性能。
在这种情况下，可以考虑增加线程池中的线程数量，以增加程序的并发处理能力。另外，可以针对无限执行的任务，采用特殊的处理措施，如定时中断或分批执行，以避免任务长时间占用线程资源。
需要注意的是，增加线程池中的线程数量虽然可以提高程序的并发处理能力，但是同时也会带来一定的系统资源消耗。因此，在设置线程池大小时需要综合考虑系统的可用资源和实际业务需求，以达到最优的性能和效率。

完整代码详解

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

class ThreadPool {
    
    
public:
    ThreadPool(size_t threadCount) : m_stop(false) {
    
    
        for (size_t i = 0; i < threadCount; ++i) {
    
    
            m_threads.emplace_back([this]() {
    
     // 利用 lambda 表达式创建线程
                while(true) {
    
    
                    std::unique_lock<std::mutex> lock(m_mutex);
                    m_cv.wait(lock, [this](){
    
     return m_stop || !m_tasks.empty(); }); // 等待任务或终止信号
                    if (m_stop && m_tasks.empty()) return;`在这里插入代码片`

                    std::function<void()> task = std::move(m_tasks.front()); // 取出任务
                    m_tasks.pop();
                    lock.unlock();
                    
                    task(); // 执行任务
                }
            });
        }
    }
    
    ~ThreadPool() {
    
    
        {
    
    
            std::unique_lock<std::mutex> lock(m_mutex);
            m_stop = true;
        }
        m_cv.notify_all();

        for (auto& thread : m_threads) {
    
    
            thread.join();
        }
    }

    template<class F, class... Args>
    void addTask(F&& f, Args&&... args) {
    
    
        std::function<void()> task = std::bind(std::forward<F>(f), std::forward<Args>(args)...);
        {
    
    
            std::unique_lock<std::mutex> lock(m_mutex);
            m_tasks.emplace(std::move(task));
        }
        m_cv.notify_one();
    }
    private:
    std::vector<std::thread> m_threads;
    std::queue<std::function<void()>> m_tasks;
    std::mutex m_mutex;
    std::condition_variable m_cv;
    bool m_stop;
    }；

该代码实现了一个简单的线程池，具有以下特点：
● 线程池中的线程数由构造函数参数指定；
● 支持添加任务，任务为可调用对象；
● 线程池在析构时会等待所有任务执行完毕并停止所有线程；
● 线程池支持多线程并发调用 addTask 方法，线程池内部使用互斥量和条件变量实现线程同步。
使用示例：

void foo(int n) {
    
    
    std::cout << "Task " << n << " is running in thread " << std::this_thread::get_id() << std::endl;
}

int main() {
    
    
    ThreadPool pool(4);
    for (int i = 0; i < 10; ++i) {
    
    
        pool.addTask(foo, i);
    }
    return 0;
}

该示例创建了一个线程池，添加了 10 个任务，每个任务为打印一段文本。可以看到，不同的任务被分配到了不同的线程中执行。

详细讲解

线程池是一种常用的多线程编程模型，它将多个任务分配给固定数量的线程来执行，避免了线程频繁创建和销毁的开销，同时也能大大提高程序的性能和效率。

线程池构造函数

在构造函数中，我们需要指定线程池中线程的数量。我们使用了 C++11 中的可变参数模板来实现支持不同类型的可调用对象。在构造函数中，我们初始化线程数组，并使用 lambda 表达式来创建每个线程的执行函数。lambda 表达式中的 while 循环会一直等待任务队列中有任务可执行，同时也会等待线程池是否已经被终止的信号。

ThreadPool(size_t threadCount) : m_stop(false) {
    
    
    for (size_t i = 0; i < threadCount; ++i) {
    
    
        m_threads.emplace_back([this]() {
    
     // 利用 lambda 表达式创建线程
            while(true) {
    
    
                std::unique_lock<std::mutex> lock(m_mutex);
                m_cv.wait(lock, [this](){
    
     return m_stop || !m_tasks.empty(); }); // 等待任务或终止信号
                if (m_stop && m_tasks.empty()) return;

                std::function<void()> task = std::move(m_tasks.front()); // 取出任务
                m_tasks.pop();
                lock.unlock();
                
                task(); // 执行任务
            }
        });
    }
}

线程池析构函数

在析构函数中，我们需要调用 join() 方法等待所有线程退出，并释放资源。同时，我们也需要设置 m_stop 信号为 true，以便线程池的执行函数能够在任务队列为空时退出。

~ThreadPool() {
    
    
    {
    
    
        std::unique_lock<std::mutex> lock(m_mutex);
        m_stop = true;
    }
    m_cv.notify_all();

    for (auto& thread : m_threads) {
    
    
        thread.join();
    }
}

添加任务函数

addTask() 函数是向线程池添加任务的函数。它使用了可变参数模板来支持不同类型的可调用对象。它首先需要将可调用对象转化为 function<void()> 类型的任务，然后将任务添加到任务队列中，并通知某个等待中的线程去执行任务。

1template<class F, class... Args>
2void addTask(F&& f, Args&&... args) {
    
    
3    std::function<void()> task = std::bind(std::forward<F>(f), std::forward<Args>(args)...);
4    {
    
    
5        std::unique_lock<std::mutex> lock(m_mutex);
6        m_tasks.emplace(std::move(task));
7    }
8    m_cv.notify_one();
9}

任务队列和同步机制

任务队列和同步机制是线程池实现的核心。在任务队列中，我们使用 std::queue<std::function<void()>> 类型来存储任务，其中 std::function<void()> 表示任意可调用对象的类型。由于多个线程会共享任务队列，因此我们需要使用互斥量（m_mutex）和条件变量（m_cv）来实现线程同步。
1std::queue<std::function<void()>> m_tasks;
2std::mutex m_mutex;
3std::condition_variable m_cv;
在执行函数中，我们使用了条件变量 m_cv 的 wait() 方法来等待任务队列中有任务可以执行。当有新任务加入或线程池被终止时，我们使用 notify_one() 方法唤醒等待中的线程。同时，我们在执行任务时需要先将任务从任务队列中取出，避免多个线程同时执行同一个任务。

std::unique_lock<std::mutex> lock(m_mutex);
m_cv.wait(lock, [this](){
    
     return m_stop || !m_tasks.empty(); }); // 等待任务或终止信号
if (m_stop && m_tasks.empty()) return;

可调用对象的包装

在添加任务时，我们需要将可调用对象进行包装，以便将不同类型的可调用对象转化为 function<void()> 类型的任务。这里我们使用了 std::bind() 方法来实现可调用对象的绑定，并使用 std::forward(f) 和 std::forward(args)… 来进行参数的转发。

template<class F, class... Args>
void addTask(F&& f, Args&&... args) {
    
    
    std::function<void()> task = std::bind(std::forward<F>(f), std::forward<Args>(args)...);
    {
    
    
        std::unique_lock<std::mutex> lock(m_mutex);
        m_tasks.emplace(std::move(task));
    }
    m_cv.notify_one();
}

总结

上面的代码实现了一个简单的线程池，可以帮助开发者更好地利用计算机的多核 CPU 提高程序的性能和效率。线程池的实现需要注意线程同步的问题，使用 std::mutex 和 std::condition_variable 可以方便地实现线程同步。同时，注意在析构函数中要等待所有任务执行完毕，以免造成资源泄漏。