C++轻量化线程池（100行）的代码实现和详细解析

项目场景：

最近工作需要用线程池，我一个C++渣渣就在github上找了一个轻量化的线程池学习一下，发现有很多异步编程的技巧不懂。所以，我把代码学习了一下，然后将自己的理解添加到注释里，和大家一起学习一下。如果我有理解不对的地方，请大家指正。

---

代码

#pragma once

#include <condition_variable>
#include <functional>
#include <future>
#include <memory>
#include <mutex>
#include <queue>
#include <stdexcept>
#include <thread>
#include <vector>

//简单线程池代码类
class ThreadPool {
 public:
  ThreadPool(size_t);
  ~ThreadPool();

  template <class F, class... Args>
  auto enqueue(F&& f, Args&&... args)
      -> std::future<typename std::result_of<F(Args...)>::type>;

 private:
  std::vector<std::thread> workers;
  std::queue<std::function<void()>> tasks;

  std::mutex queue_mutex;
  std::condition_variable condition;
  bool stop;
};

// 构造函数：构建一个一直在循环的for循环，来等待enqueue函数来塞线程进来。
// 该类被析构的时候，并且线程池里面的线程都执行完了，退出for循环
inline ThreadPool::ThreadPool(size_t threads_size) : stop(false) {
  // 根据构造时候传入的参数，在std::vector中塞入固定数目的线程
  for (size_t i = 0; i < threads_size; ++i) {
    // 每一个线程中都有一个一直循环的for，来等待任务
    workers.emplace_back([this] {
      for (;;) {
        std::function<void()> task;

        {
          std::unique_lock<std::mutex> lock(this->queue_mutex);
          // wait()会阻塞住该线程，如果实例被析构或者有任务来了，则返回true到下面去执行任务
          // 如果没有以上条件，就一直阻塞在这
          this->condition.wait(
              lock, [this] { return this->stop || !this->tasks.empty(); });
          if (this->stop && this->tasks.empty()) return;
          // 把任务从队列中取出来
          task = std::move(this->tasks.front());
          this->tasks.pop();
        }
        // 执行任务
        task();
      }
    });
  }
}

// 往线程池容器中塞入任务，这个函数是一个模板函数，接受一个模板类和不限个数的形参
// 这里->后面是给编译期一个提示，指明该函数的返回值是这种格式
// std::future是获取异步任务结果的一个工具，返回这个值的目的是允许获取任务的结果或等待任务完成
// typename是为了告诉编译器后面的内容是一个类，后面是将Args作为F的形参，然后将F的返回作为该函数的返回
template <class F, class... Args>
auto ThreadPool::enqueue(F&& f, Args&&... args)
    -> std::future<typename std::result_of<F(Args...)>::type> {
  // 将任务函数F的返回值声明成一个简短的名称，可以提高代码的可读性
  using return_type = typename std::result_of<F(Args...)>::type;

  // 用std::packaged_task封装一个任务函数，函数返回类型是return_type，
  // 函数内容是F(Args),实现方法是用std::bind将形参和任务函数绑定在一起
  // 所以这一句的作用是，生成一个返回参数是return_type的F(Args)的封装对象的智能指针
  auto task = std::make_shared<std::packaged_task<return_type()>>(
      std::bind(std::forward<F>(f), std::forward<Args>(args)...));

  // 获取任务函数的future，并将任务函数塞入线程池里
  std::future<return_type> res = task->get_future();
  {
    std::lock_guard<std::mutex> lock(queue_mutex);

    if (stop) throw std::runtime_error("enqueue on stopped ThreadPool");
    //塞入线程池
    tasks.emplace([task]() { (*task)(); });
  }

  // 通知异步等待的线程，可以开始干活了
  condition.notify_one();
  return res;
}

inline ThreadPool::~ThreadPool() {
  // 输出停止信号，清空所有的线程
  {
    std::unique_lock<std::mutex> lock(queue_mutex);
    stop = true;
  }
  condition.notify_all();
  for (std::thread& worker : workers) worker.join();
}