线程池-手写线程池C++11版本（生产者-消费者模型）

bool ZERO_ThreadPool::init(size_t num)
{
  std::unique_lock<std::mutex> lock(mutex_);
  if (!threads_.empty())
  {
    return false;
  }
  threadNum_ = num;
  return true;
}

bool ZERO_ThreadPool::get(TaskFuncPtr& task)
{
  std::unique_lock<std::mutex> lock(mutex_);
  if (tasks_.empty()) //判断任务是否存在
  {
    //要终止线程池   bTerminate_设置为true,任务队列不为空
    condition_.wait(lock, [this] { return bTerminate_ || !tasks_.empty(); });
  }
  if (bTerminate_)
    return false;
  if (!tasks_.empty())
  {
    task = std::move(tasks_.front());  // 使用了移动语义
    tasks_.pop(); //释放资源，释放一个任务
    return true;
  }
  return false;
}

void ZERO_ThreadPool::run()  // 执行任务的线程
{
  //调用处理部分
  while (!isTerminate()) // 判断是不是要停止
  {
    TaskFuncPtr task;
    bool ok = get(task);        // 读取任务
    if (ok)
    {
      ++atomic_;
      try
      {
        if (task->_expireTime != 0 && task->_expireTime < TNOWMS)
        {//如果设置了超时，并且超时了，就需要执行本逻辑
        //超时任务，本代码未实现，有需要可实现在此处
        }
        else
        {
          task->_func();  // 执行任务
        }
      }
      catch (...)
      {
      }
      --atomic_;
      }
    }
  }
}

bool ZERO_ThreadPool::start()
{
  std::unique_lock<std::mutex> lock(mutex_);
  if (!threads_.empty())
  {
    return false;
  }
  for (size_t i = 0; i < threadNum_; i++)
  {
    threads_.push_back(new thread(&ZERO_ThreadPool::run, this));
  }
  return true;
}

/*
  template <class F, class... Args>
  它是c++里新增的最强大的特性之一，它对参数进行了高度泛化，它能表示0到任意个数、任意类型的参数
  auto exec(F &&f, Args &&... args) -> std::future<decltype(f(args...))>
  std::future<decltype(f(args...))>：返回future，调用者可以通过future获取返回值
  返回值后置
  */
  template <class F, class... Args>
  auto exec(int64_t timeoutMs, F&& f, Args&&... args) -> std::future<decltype(f(args...))>//接受一个超时时间 `timeoutMs`，一个可调用对象 `f` 和其它参数 `args...`，并返回一个 `std::future` 对象，该对象可以用于获取任务执行的结果。
  {
    int64_t expireTime = (timeoutMs == 0 ? 0 : TNOWMS + timeoutMs);  // 根据超时时间计算任务的过期时间 `expireTime`，如果超时时间为 0，则任务不会过期。
    //定义返回值类型
    using RetType = decltype(f(args...));  // 使用 `decltype` 推导出 `f(args...)` 的返回值类型，并将其定义为 `RetType`(这里的using和typedef功能一样，就是为一个类型起一个别名)。
    // 封装任务 使用 `std::packaged_task` 将可调用对象 `f` 和其它参数 `args...` 封装成一个可执行的函数，并将其存储在一个 `std::shared_ptr` 对象 `task` 中。
    auto task = std::make_shared<std::packaged_task<RetType()>>(std::bind(std::forward<F>(f), std::forward<Args>(args)...));
    TaskFuncPtr fPtr = std::make_shared<TaskFunc>(expireTime);  // 封装任务指针，设置过期时间 创建一个 `TaskFunc` 对象，并将任务的过期时间 `expireTime` 传递给它。
    fPtr->_func = [task]() {  // 具体执行的函数 将封装好的任务函数存储在 `TaskFunc` 对象的 `_func` 成员中，该函数会在任务执行时被调用。
      (*task)();
    };
    std::unique_lock<std::mutex> lock(mutex_);
    tasks_.push(fPtr);              // 将任务插入任务队列中
    condition_.notify_one();        // 唤醒阻塞的线程，可以考虑只有任务队列为空的情况再去notify
    return task->get_future();; //返回一个 `std::future` 对象，该对象可以用于获取任务执行的结果。
  }

bool ZERO_ThreadPool::waitForAllDone(int millsecond)
{
  std::unique_lock<std::mutex> lock(mutex_);
  if (tasks_.empty() && atomic_ == 0)
    return true;
  if (millsecond < 0)
  {
    condition_.wait(lock, [this] { return tasks_.empty() && atomic_ == 0; });
    return true;
  }
  else
  {
    return condition_.wait_for(lock, std::chrono::milliseconds(millsecond), [this] { return tasks_.empty() && atomic_ == 0; });
  }
}

void ZERO_ThreadPool::stop()
{
  {
    std::unique_lock<std::mutex> lock(mutex_);
    bTerminate_ = true;
    condition_.notify_all();
  }
  waitForAllDone();
  for (size_t i = 0; i < threads_.size(); i++)
  {
    if (threads_[i]->joinable())
    {
      threads_[i]->join();
    }
    delete threads_[i];
    threads_[i] = NULL;
  }
  std::unique_lock<std::mutex> lock(mutex_);
  threads_.clear();
}

class Test
{
public:
  int test(int i) {
    cout << _name << ", i = " << i << endl;
    Sleep(1000);
    return i;
  }
  void setName(string name) {
    _name = name;
  }
  string _name;
};
void test3() // 测试类对象函数的绑定
{
  ZERO_ThreadPool threadpool;
  threadpool.init(2);
  threadpool.start(); // 启动线程池
  Test t1;
  Test t2;
  t1.setName("Test1");
  t2.setName("Test2");
  auto f1 = threadpool.exec(std::bind(&Test::test, &t1, std::placeholders::_1), 10);
  auto f2 = threadpool.exec(std::bind(&Test::test, &t2, std::placeholders::_1), 20);
  cout << "t1 " << f1.get() << endl;
  cout << "t2 " << f2.get() << endl;
  threadpool.stop();
}
int main()
{
  test3(); // 测试类对象函数的绑定
  cout << "main finish!" << endl;
  return 0;
}