写一个简单的线程池

线程池代码（代码太少了就不分cpp/h了）：

#include <condition_variable>
#include <deque>
#include <iostream>
#include <mutex>
#include <thread>

class ThreadPool {
  using Task = std::function<void(void)>;

 private:
  bool stop_flag_;                     //线程停止标志值
  const int thread_num_;               //线程数
  std::mutex task_mutex_;              //任务数据锁
  std::condition_variable task_cond_;  //任务数据的条件变量
  std::deque<Task> task_queue_;  //任务队列（高优先级任务可以推到头部）
  std::vector<std::thread> threads_;  //线程

 public:
  explicit ThreadPool(int thread_num = 1)
      : thread_num_(thread_num), stop_flag_(false) {
    const int max_thread = std::thread::hardware_concurrency();
    if (thread_num_ > max_thread) {  //限制线程数量
      std::wclog << "max thread is " << max_thread << std::endl;
      std::wclog << "thread trim to " << max_thread << std::endl;
    }
    for (int i = 0; i < std::min(thread_num_, max_thread); ++i) {
      threads_.emplace_back(std::thread(std::bind(&ThreadPool::Execute, this)));
    }
  }

  //添加任务
  void AddTask(Task task) {
    std::unique_lock<std::mutex> lock(task_mutex_);
    task_queue_.push_back(std::move(task));
    task_cond_.notify_all();
  }
  //关闭线程池
  void Halt() {
    stop_flag_ = true;
    std::unique_lock<std::mutex> lock(task_mutex_);
    std::cout << task_queue_.size() << " tasks remain~~~~ " << std::endl;
    std::cout << "halt.........." << std::endl;
    task_queue_.clear();
    task_queue_.push_back([]() { return; });
    task_cond_.notify_all();
    lock.unlock();
    std::cout << threads_.size() << " threads remain " << std::endl;
    for (auto it = threads_.begin(); it != threads_.end(); ++it) {
      if (it->joinable()) {
        std::cout << "thread " << it->get_id() << " join " << std::endl;
        it->join();
      }
    }
  }
  ~ThreadPool() {}

 private:
  //执行任务
  void Execute() {
    const auto thread_id = std::this_thread::get_id();
    while (!stop_flag_) {
      std::unique_lock<std::mutex> lock(task_mutex_);
      if (task_queue_.size()) {
        auto task = task_queue_.front();
        task_queue_.pop_front();
        lock.unlock();
        std::cout << "thread id : " << thread_id << " start " << std::endl;
        task();
        std::cout << "thread id : " << thread_id << " stoped " << std::endl;
      } else {
        std::cout << "thread id : " << thread_id << " wait " << std::endl;
        task_cond_.wait(lock, [&]() { return task_queue_.size(); });
      }
    }
  }
};

测试代码：

int main(void) {
  ThreadPool thread_pool(11);
  //耗时函数
  auto cost_calcu = [](int cost_time) {
    std::this_thread::sleep_for(std::chrono::milliseconds(cost_time));
  };
  int cost_time = 0;
  for (int i = 0; i < 8; ++i) {
    cost_time = 1500 - i * 50;
    thread_pool.AddTask(std::bind(cost_calcu,cost_time));
  }
  cost_calcu(10000);//10s等待现有任务做完
  thread_pool.AddTask(std::bind(cost_calcu,2000));
  thread_pool.AddTask(std::bind(cost_calcu,1500));
  cost_calcu(10);//等10ms
  thread_pool.Halt();
  return 0;
}