C++11并发学习之六：一个简洁牛逼的线程池(有返回值)

为什么要使用线程池？
大多数网络服务器，包括Web服务器、Email服务器以及数据库服务器等都具有一个共同点，就是单位时间内必须处理数目巨大的连接请求，但处理时间却相对较短。
       传统多线程方案是“即时创建，即时销毁”的策略。
线程分为三个过程：T1、T2、T3。
T1：线程创建时间
T2：线程执行时间，包括线程的同步等时间
T3：线程销毁时间
线程本身的开销所占的比例为(T1+T3) / (T1+T2+T3)。如果线程执行的时间很短的话，开销可能占到20%-50%左右。如果任务执行时间很长的话，这笔开销将是不可忽略的。
       除此之外，线程池能够减少创建的线程个数。
       因此线程池的出现正是着眼于减少线程本身带来的开销。线程池采用预创建的技术。
对于FTP服务器以及Telnet服务器，通常传送文件的时间较长，开销较大，那么此时，我们采用线程池未必是理想的方法，我们可以选择“即时创建，即时销毁”的策略。
总之线程池通常适合下面的几个场合：
(1)单位时间内处理任务频繁而且任务处理时间短
(2)对实时性要求较高。如果接受到任务后在创建线程，可能满足不了实时要求，因此必须采用线程池进行预创建。

感谢github上大神的分享：https://github.com/progschj/ThreadPool

代码非常的简洁，只有一个头文件ThreadPool.h，这里贴出来作为备份。

#ifndef TG_THREAD_POOL_H
#define TG_THREAD_POOL_H

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

class tg_thread_pool
{
public:
    tg_thread_pool(size_t);
    template<class F, class... Args>
    auto enqueue(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type>;
    ~tg_thread_pool();
private:
    std::vector<std::thread> _threads;
    std::queue<std::function<void()>> _que;

    std::mutex _mutex;
    std::condition_variable _condition;
    bool _stop;
};

inline tg_thread_pool::tg_thread_pool(size_t num) : _stop(false)
{
    for(size_t i = 0;i<num;++i)
    {
        _threads.emplace_back(
            [this]
            {
                for(;;)
                {
                    std::function<void()> task;

                    {
                        std::unique_lock<std::mutex> lock(this->_mutex);
                        this->_condition.wait(lock, [this]{ return this->_stop || !this->_que.empty(); });
                        if(this->_stop && this->_que.empty())
                        {
                            return;
                        }

                        task = std::move(this->_que.front());
                        this->_que.pop();
                    }

                    task();
                }
            }
        );
    }
}

template<class F, class... Args>
auto tg_thread_pool::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(_mutex);

        if(_stop)
            throw std::runtime_error("enqueue on stopped ThreadPool");

        _que.emplace([task](){ (*task)(); });
    }
    _condition.notify_one();
    return res;
}

inline tg_thread_pool::~tg_thread_pool()
{
    {
        std::unique_lock<std::mutex> lock(_mutex);
        _stop = true;
    }
    _condition.notify_all();
    for(std::thread &worker: _threads)
        worker.join();
}

#endif // TG_THREAD_POOL_H

基本使用方法

#include <iostream>
#include "./other/tg_thread_pool.h"

void func()
{
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::cout<<"worker thread ID:"<<std::this_thread::get_id()<<std::endl;
}

int main()
{
    tg_thread_pool pool(4);
    auto result = pool.enqueue([](int answer) { return answer; }, 42);

    std::cout << result.get() << std::endl;//42
    for(int i=0;i<10;i++)
    {
        pool.enqueue(func);
    }

    return 0;
}

可以看出，四个线程都在运行。