C++百行项目，实现多线程池，ThreadPool代码解析_c++ threadpool

1、介绍

        该项目是一个实现多线程池的简单项目，我将它作为简单的C++项目入门，代码并不多但是精读该代码对于学习C++的新特性以及线程实现有很好的作用。本文会详细讲解代码及使用的库特性，作为初学者如有错误敬请指正。

2、头文件

2.1、头文件包含的库

#ifndef THREAD_POOL_H
#define THREAD_POOL_H
 
#include <vector>
#include <queue>
#include <memory>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <future>
#include <functional>
#include <stdexcept>

        memory库：智能指针库，操作用std::shared_ptr或std::make_shared创建指针，通过该库创建的指针可以在不再需要指针后自动释放，避免在线程未结束前指针被释放引起崩溃。

        thread库：线程库，通过std::thread创建线程，并通过.join()保护线程防止在其他线程未结束之前主线程结束，.joinabel()判断是否可以保护线程。

        mutex库：互斥锁库，配合线程使用防止不同线程对同一个变量进行操作，整个文件中只能有一个互斥锁定义std::mutex mtx。最简单的操作方式是在写操作之前mtx.lock()锁进程，用mtx.unlock()解锁进程。最最常用的方式是std::unique_lock<std:mutex> lg(mtx)，当构造函数调用时，互斥量自动锁定，当析构函数调用时，互斥量自动释放。并且它只能在局部作用域中使用。相比于std::lock_guard<std:mutex> lg(mtx)，std::unique_lock<std:mutex> lg(mtx)有能够限时等待的操作方式。

        condition_variable库：条件变量库，std::condition_variable cv配合互斥锁使用，cv.wait(lock,false):需要等待。cv.notify_one():通知消费者来取任务。

        future库：异步编程库，在该项目中很重要，因为future可以在不调用拷贝构造函数的情况下获取线程，不是为了节省内存！！！！！是因为线程不能调用拷贝构造函数。

2.2、类

class ThreadPool {
public:
    ThreadPool(size_t);
    template<class F, class... Args>
    auto enqueue(F&& f, Args&&... args) 
        -> std::future<typename std::result_of<F(Args...)>::type>;
    ~ThreadPool();
private:
    std::vector< std::thread > workers;
    std::queue< std::function<void()> > tasks;
    
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
};

        文件中只有一个类，有一个构造函数、一个析构函数以及一个成员函数enqueue，其中成员函数enqueue是为了添加线程。成员有5个，workers线程数组，tasks任务队列（函数作为元素），queue_mutex互斥锁，condition环境变量，stop线程池终止变量。

        在学习过程中最难了解的是enqueue的定义，其用到了万能引用&&。在C++中左值引用为&，右值引用为&&，在函数模板中才有万能模板&&可以根据数据进行左值引用和右值引用的调整。其中f是函数，args是函数参数，...表示函数参数数量不受限制。 -> std::future<typename std::result_of<F(Args...)>::type>表示auto的返回值固定为std::future。

2.3、构造函数

inline 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();
                }
            }
        );
}

        首先为stop进行赋值，之后对线程进行任务分配，workers通过使用emplace_back进行push_back，同样因为push_back会调用拷贝构造函数，而thread不能使用拷贝构造函数。

        在emplace_back中使用了lambda表达式并捕获类内所有局部变量(即this指针所能获取的所有成员)。由于使用了内联函数的原因，不能使用while只能使用for(;;)。其中一些空的{}是为了作为局部作用域，解除互斥锁。

        如果在for(;;)中没有任务可分配了那么就等待任务到达分配，如果stop被置true那么就直接结束构造函数。有任务立即执行！！！！！！

        非常重要的一点std::move为从一个对象转移到另一个对象而不经过拷贝构造函数的操作，最后task执行。

2.4、任务添加成员函数

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);
 
        if(stop)
            throw std::runtime_error("enqueue on stopped ThreadPool");
 
        tasks.emplace([task](){ (*task)(); });
    }
    condition.notify_one();
    return res;
}

        该成员函数使用auto作为返回值类型，并通过->指定返回类型，其中std::result_of<F(Args...)>::type用以获取函数返回结果，typename确定类型，std::future来保存结果。

        为了方便之后指定类型，使用using return_type = typename std::result_of<F(Args...)>::type保存输出结果的类型。

        这里对task使用了std::make_shared进行智能指针的使用，std::packaged_task封装异步操作，使其能不调用拷贝构造函数的情况下获取结果。

        使用std::bind进行函数参数绑定，std::forward完美转发使其能够在左值引用和右值引用通用。

        利用test指针获取.get_future()函数获取future并通过.get()获取值。这里有个重要小技巧，可以通过promise对象跨线程获取值。

        最后通过*task获取最终结果，在加入任务成功后利用condition.notify_one()通知线程过来取任务。来活了兄弟们！！！

2.5、析构函数

inline ThreadPool::~ThreadPool()
{
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        stop = true;
    }
    condition.notify_all();
    for(std::thread &worker: workers)
        worker.join();
}

        互斥锁全局只有一个，在任务结束之前不允许其他线程调用，因此这里的操作必须在所有线程都执行结束后才能进行，首先互斥锁上锁，将stop置true。

        condition.notify_all()通知各线程将任务队列中的所有任务做完，之后检查每个线程都是否结束，最后结束主线程。

3、结语

        找工作学习的第一个小项目，如有错误敬请指正讨论，一起提高。