thread_pool.hpp

Go to the documentation of this file.

#pragma once
#include <atomic>
#include <cassert>
#include <condition_variable>
#include <functional>
#include <future>
#include <memory>
#include <queue>
#include <thread>
#include <toast/export.hpp>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace toast {

class TOAST_API ThreadPool {
public:
  static auto create() noexcept -> std::unique_ptr<ThreadPool>;

  template<typename T>
  static auto push(T&& job) -> std::future<std::invoke_result_t<T>>;

  static void pushRaw(std::move_only_function<void()>&& job);

  void destroy();

  [[nodiscard]] [[deprecated("Use waitIdle() instead")]]
  auto busy() -> bool;

  void waitIdle();
 
  static auto workerCount() -> size_t;

  [[nodiscard]]
  static auto idleWorkers() noexcept -> size_t;

  [[nodiscard]]
  static auto onWorkerThread() noexcept -> bool;
 
  // No copy and move constructors
  ThreadPool(ThreadPool&) = delete;
  ThreadPool(ThreadPool&&) = delete;
  auto operator=(const ThreadPool&) -> ThreadPool& = delete;
  auto operator=(ThreadPool&&) -> ThreadPool& = delete;
 
  ~ThreadPool() {
    waitIdle();
    destroy();
  }
 
private:
  ThreadPool();
  inline static ThreadPool* instance = nullptr;
  static auto get() noexcept -> ThreadPool&;
 
  void threadLoop();
  static void enqueue(std::move_only_function<void()>&& job);
 
  struct {
    bool should_stop = false;                            
    std::atomic<int> active_jobs = 0;                    
    std::atomic<int> idle_workers = 0;                   
    std::mutex queue_mutex;                              
    std::condition_variable job_available;               
    std::condition_variable all_done;                    
    std::vector<std::jthread> workers;                   
    std::queue<std::move_only_function<void()>> jobs;    
  } m;
};
 
template<typename T>
auto ThreadPool::push(T&& job) -> std::future<std::invoke_result_t<T>> {
  using result_t = std::invoke_result_t<T>;
 
  std::packaged_task<result_t()> task(std::forward<T>(job));
  auto future = task.get_future();
  enqueue([task = std::move(task)]() mutable { task(); });
  return future;
}
 
}