线程池就是一个装着线程的池子，实现了线程的复用，主要有任务队列线程队列
外面不断有任务进入任务队列，线程池不断从任务队列中取任务，当一个线程完
成当前任务，且任务队列为空，当前线程进入等待状态，阻塞，且不断循环检查任
务队列是否有任务，添加任务取出任务通过条件变量和互斥锁实现同步

// 线程池
class ThreadPool {
 public:
  // 初始化线程池
  ThreadPool(int thread_num) : thread_num_(thread_num), stop_(false) {
    for (int i = 0; i < thread_num_; ++i) {
      // 创建线程
      threads_.emplace_back([this] {
        while (true) {
          std::function<void()> task;
          {
            // 创建互斥量，保证任务获取和任务添加互斥进行
            std::unique_lock<std::mutex> lock(queue_mutex_);
            // 等待任务队列不为空，当任务队列为空时，线程将被挂起
            condition_.wait(lock, [this] { return stop_ || !tasks_.empty(); });
            // 如果线程池停止了，则退出
            if (stop_ && tasks_.empty()) return;
            // 取出一个任务进行执行
            task = std::move(tasks_.front());
            tasks_.pop();
          }
          // 执行任务
          task();
        }
      });
    }
  }
  // 销毁线程池
  ~ThreadPool() {
    {
      std::unique_lock<std::mutex> lock(queue_mutex_);
      stop_ = true;
    }
    // 唤醒所有线程，让它们退出
    condition_.notify_all();
    // 等待所有线程安全退出
    for (std::thread &worker : threads_) {
      worker.join();
    }
  }
  // 提交任务
  template <typename F, typename... Args>
  auto 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(queue_mutex_);
      // 添加任务到队列中，并通知一个线程来取走该任务
      tasks_.emplace([task]() { (*task)(); });
    }
    condition_.notify_one();
    return res;
  }

 private:
  // 线程池容量
  int thread_num_;
  // 线程队列
  std::vector<std::thread> threads_;
  // 任务队列
  std::queue<std::function<void()>> tasks_;
  // 互斥锁
  std::mutex queue_mutex_;
  // 条件变量
  std::condition_variable condition_;
  // 是否停止线程池
  bool stop_;
};