thread_pool.h

Go to the documentation of this file.

#ifndef SRC_SCANNER_LIB_THREAD_POOL_H_
#define SRC_SCANNER_LIB_THREAD_POOL_H_
 
#include <condition_variable>
 
#include <atomic>
#include <functional>
#include <future>
#include <mutex>
#include <queue>
#include <thread>
#include <type_traits>
#include <vector>
 
namespace scanner {
 
class ThreadPool {
public:
  explicit ThreadPool(std::size_t num_threads = 0);
 
  ~ThreadPool();
 
  ThreadPool(const ThreadPool&) = delete;
  ThreadPool& operator=(const ThreadPool&) = delete;
  ThreadPool(ThreadPool&&) = delete;
  ThreadPool& operator=(ThreadPool&&) = delete;
 
  void Stop();
 
  template <class F, class... Args>
  auto Enqueue(F&& f, Args&&... args)
      -> std::future<std::invoke_result_t<F, Args...>>;
 
private:
  void Worker();
 
  std::vector<std::thread> workers_;
  std::queue<std::function<void()>> tasks_;
 
  std::mutex queue_mutex_;
  std::condition_variable condition_;
  std::atomic<bool> stop_{false};
};
 
template <class F, class... Args>
auto ThreadPool::Enqueue(F&& f, Args&&... args)
    -> std::future<std::invoke_result_t<F, Args...>> {
  using return_type = std::invoke_result_t<F, Args...>;
 
  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_);
 
    // Don't allow enqueueing after stopping.
    if (stop_.load()) {
      throw std::runtime_error("Enqueue on stopped ThreadPool");
    }
 
    tasks_.emplace([task]() { (*task)(); });
  }
  condition_.notify_one();
  return res;
}
 
}  // namespace scanner
 
#endif  // SRC_SCANNER_LIB_THREAD_POOL_H_