c++11线程池

 #pragma once

 #include <future>

 #include <vector>

 #include <atomic>

 #include <queue>

 #include <thread>

 #include <mutex>

 namespace std {

 //线程池最大容量,应尽量设小一点
 #define THREADPOOL_MAX_NUM 16

 class ThreadPool
 {
 public:
     ThreadPool(unsigned short size = ) { AddThread(size); }
     ~ThreadPool()
     {
         if (_run.load())
         {
             Close();
         }
     }

     void Close()
     {
         _run.store(false);
         //唤醒所有线程执行
         _task_cv.notify_all();
         for (thread &th : _pool)
         {
             if (th.joinable())
                 th.join();
         }
     }

     //提交一个任务，
     template<class F, class... Args>
     auto commit(F&& f, Args&&... args) ->future<decltype(f(args...))>
     {
         if (!_run)
             throw runtime_error("commit on ThreadPool is stop.");
         // typename std::result_of<F(Args...)>::type, 函数 f 的返回值类型
         using RetType = decltype(f(args...));
         //把函数入口及参数打包
         auto task = make_shared<packaged_task<RetType()>>(bind(forward<F>(f), forward<Args>(args)...));

         future<RetType> future = task->get_future();
         {
             lock_guard<mutex> lock{ _lock };
             _tasks.emplace([task]() {(*task)(); });
         }
 #ifdef THREADPOOL_AUTO_GROW if (_id1ThrNum <  && _pool.size() < THREADPOOL_MAX_NUM) AddThread(); #endif _task_cv.notify_one(); return future; }

 int IdlCount() { return _id1ThrNum; }
     int BusyCount() { return _pool.size(); }

     void AddThread(unsigned short size)
     {
         for (; _pool.size() < THREADPOOL_MAX_NUM && size > ; --size)
         {
             _pool.emplace_back([this] {
                 while (_run.load())
                 {
                     Task task;
                     {
                         unique_lock<mutex> lock{ _lock };
                         _task_cv.wait(lock, [this]
                         {
                             return !_run.load() || !_tasks.empty();
                         });
                         if (!_run.load() && _tasks.empty())
                             return;
                         task = move(_tasks.front());
                         _tasks.pop();
                     }
                     _id1ThrNum--;
                     task();
                     _id1ThrNum++;
                 }
             });
             _id1ThrNum--;
         }
     }

 public:
     //定义类型
     using Task = std::function<void()>;
     //线程池
     vector<thread> _pool;
     //锁
     mutex _lock;
     //任务队列
     queue<Task> _tasks;
     //条件阻塞
     condition_variable _task_cv;
     //线程是否在执行
     atomic<bool> _run{ true };
     //空闲线程
     atomic<int> _id1ThrNum{  };
 };
 }