学习基于C++0x的threadpool简单实现

学习了网上一片文章基于c++0x实现的threadpool，使用了很多新特性，学习了一番之后很有收获，加了注释希望可以帮助更多人。

文章链接：https://cloud.tencent.com/developer/article/1478195

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

class ThreadPool
{
public:
    ThreadPool(int size);

    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 _mutex;
    std::condition_variable _cond_var;
    bool stop;
};

ThreadPool::ThreadPool(int size):stop(false)
{
    for(int i = 0; i < size; i++)
    {
        workers.emplace_back(
            [this] ()
            {
                // 每个线程循环工作
                for (;;)
                {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(this->_mutex);
                        // 当队列为空 或者 没有停止pool时，会阻塞在这里，直到有任务
                        this->_cond_var.wait(lock, [this] ()
                        {
                            return this->stop || !this->tasks.empty();
                        });
                        // 对应析构中 notify_all 此时 stop 为 true
                        if (this->stop || this->tasks.empty())
                        {
                            return;
                        }
                        task = std::move(this->tasks.front());
                        this->tasks.pop();
                    }
                    task();
                }
            }
        );
    }
}

/**
 * 这个看起来很复杂的定义是
 * 定义了函数 enqueue， 接收两个模板类型的参数， F类型 和 Args类型
 * F类型是函数，Args类型是参数列表
 * 返回值类型是 std::future<>， future返回的具体类型是 typename std::result_of<F(Args...)>::type ， auto 是占位符
 * typename std::result_of<F(Args...)>::type 的意思是，方法 F(Args...) 的返回值的类型
 * 所以就是 std::future<F(Args...)> enqueue(F, Args...)
 * 可能出现的问题，就是塞入了太多的任务，导致队列内存爆掉
 */
template<class F, class... Args>
auto ThreadPool::enqueue(F&& f, Args... args) -> std::future<typename std::result_of<F(Args...)>::type>
{
    // get return type
    using return_type = typename std::result_of<F(Args...)>::type;
    // create task
    // std::make_shared 产生了一个指针，指向了一个方法，方法是一个 std::packaged_task<> 包装的task，
    // 类型的签名是 return_type() 就是无参数，返回值类型 return_type
    auto task = std::make_shared<std::packaged_task<return_type()>>(
        std::bind(std::forward<F>(f), std::forward<Args>(args)...)
    );
    // get futre
    std::future<return_type> ret = task->get_future();
    {
        std::unique_lock<std::mutex> lock(_mutex);
        if (stop)
        {
            std::cout << "thread pool has stopped";
            throw std::runtime_error("pool stopped");
        }
        tasks.emplace([task] ()
        {
            (*task)();
        });
    }
    // notify_one 之后不一定能立刻执行，有空闲的线程才执行，没有就在队列里等待
    _cond_var.notify_one();
    return ret;
}

ThreadPool::~ThreadPool()
{
    // 停止pool前要锁住
    {
        std::unique_lock<std::mutex> lock(_mutex);
        stop = true;
    }
    // 要通知多有的线程都停止工作，并join掉所有的线程
    _cond_var.notify_all();
    for (auto& item: workers)
    {
        item.join();
    }
}

int main()
{
    ThreadPool _pool(4);
    /////////////////////////////////////////////////////////////
    auto result1 = _pool.enqueue([](int ans)
    {
        return ans;
    }, 100);
    std::cout << "ret:" << result1.get() << std::endl;

    /////////////////////////////////////////////////////////////
    auto result2 = _pool.enqueue([](char ans)
    {
        return ans;
    }, 'a');
    std::cout << "ret:" << result2.get() << std::endl;

    /////////////////////////////////////////////////////////////
    auto result3 = _pool.enqueue([](float ans)
    {
        return ans;
    }, 1.23);
    std::cout << "ret:" << result3.get() << std::endl;

    /////////////////////////////////////////////////////////////
    auto result4 = _pool.enqueue([](std::string ans)
    {
        return ans;
    }, "hello world");
    std::cout << "ret:" << result4.get() << std::endl;

    return 0;
}