这一部分主要就是线程池的实现，然后写一个对外接口，将任务提交到任务队列，然后用多线程理任务。（这一部分主要内容就是任务函数的返回类型解析，多入参函数的解析，要确保多个入参可以被线程池解析出来，并且执行）。
这里的函数主要用到的是 <functional> 这个类，利用std::bind（）将函数和参数进行绑定。参数使用c++11的新特性，可变参数模板。就可以实现。
class ThreadPool
{
public:
//线程池构造函数
ThreadPool();
//1, 提交函数
template<typename F, typename... Args>
auto Enqueue(F&& f, Args &&...args)->std::future<decltype(f(args...))> ;
// 析构函数
inline ~ThreadPool();
private:
// 线程池
std::vector<std::thread> worker_;
// 任务队列
BoundedQueue<std::function<void()>> task_queue_;
// 退出线程池标志位
std::atomic_bool stop_;
};1、构造函数
//线程池构造函数
explicit ThreadPool(std::size_t thread_mun, std::size_t max_task_num = 1000) : stop_(false)
{
// 初始化失败抛出异常
if (!task_queue_.Init(max_task_num, new SleepWaitStratrgy)) { // SleepWaitStratrgy BlockWaitStrategy
throw std::runtime_error("Task queue init failed");
}
// 存放多个 std::thread线程对象
worker_.reserve(thread_mun);
for (size_t i = 0; i < thread_mun; i++)
{
// 使用lamdba 表达式来创建每个线程
// 功能是 从任务队列中获取任务，并且执行任务的函数对象
worker_.emplace_back([this] {
while (!stop_)
{
std::function<void()> task;
if (task_queue_.WaitDequeue(&task)) {
task();
}
}
});
}
}1、对任务队列进行初始化。
2、修改一个线程对象大小。
3、在线程队列中，构造线程，并且轮流从线程池中用WaitDequeue(&task)函数，获取任务。并且运行任务。
2、提交任务函数
template<typename F, typename... Args>
auto Enqueue(F&& f, Args &&...args)->std::future<decltype(f(args...))> {
std::function<decltype(f(args...))()> func =
std::bind(std::forward<F>(f), std::forward<Args>(args)...);
auto task =
std::make_shared<std::packaged_task<decltype(f(args...))()>>(func);
// 任务队列的入队 并且唤醒线程
task_queue_.Enqueue([task]() {(*task)();});
return task->get_future();
}这个也是核心关键部分。
1、头部函数模板是利用的，可变参数模板来接受多个参数。
template<typename F, typename... Args>2、这个头部函数名
auto Enqueue(F&& f, Args &&...args)->std::future<decltype(f(args...))> auto：动推导函数类型。
Enqueue(F&& f, Args &&...args)：两个入参，一个是万能引用，一个是可变参数模板。（这里的&&不是右值引用，万能引用可以简单理解为，当T是模板参数时，T&&的作用主要是保持值类别进行转发。）
->std::future<decltype(f(args...))> ：c++11中关键字decltype解决了auto关键字只能对变量类型进行类型推导的缺陷。用于弥补auto，不能直接推导函数类型。
std::future<>：异步推导，需要用到的时候再调用结果，不需要函数阻塞再原地，等待decltype推导函数类型。
3、
std::function<decltype(f(args...))()> func =
std::bind(std::forward<F>(f), std::forward<Args>(args)...);
定义一个func 类型是通用函数模板类，用decltype去推导函数类型。再由std::function 中的bind函数，将函数和其参数进行绑定。这里用到了std::forward() 完美转发，是因为我们这里的 “ f ”，传过来的时候不是右值，是一个"引用"，然而，一个绑定到 完美引用 上的对象可能具 是个左值 或者也可能是个右值，正是因为有这种二义性，所以产生了std::forward。
4、
auto task = std::make_shared<std::packaged_task<decltype(f(args...))()>>(func);
这里我们使用了std::make_shared方法，声明了一个std::packaged_task<decltype(f(args...))()>类型的智能指针，并且将前面的 func 作为std::package_task的参数传入。智能指针更方便的我们对package_task进行管理。
package_tas可以用来封装任何可以调用的目标，从而用于实现异步的调用。
5、
task_queue_.Enqueue([task]() {(*task)();});
return task->get_future();任务入队，然后调用，task的get_future() 获取异步结果的方法。
我们返回了一个 future 对象，因此我们可以将其返回给调用者，由调用者自行决定何时调用 get() 方法获取异步操作的结果
3、析构函数
// 析构函数
inline ~ThreadPool() {
// 防止重复析构， （将stop_改变成true，并且返回之前的值）
if (stop_.exchange(true)) {
return;
}
// 线程池中所有线程停止
task_queue_.BreakAllWait();
// 并且等待他们完成所有任务
for (std::thread& worker : worker_)
{
worker.join();
}
}这里的析构基本上就是基本的函数析构逻辑，解放所有的资源。
到此为止，整个线程池也就全部结束了。