thread_pool.h

#pragma once
 
#include <condition_variable>
#include <functional>
#include <future>
#include <mutex>
#include <queue>
#include <stdexcept>
#include <thread>
#include <vector>
 
namespace pixelbullet
{
class ThreadPool
{
public:
    explicit ThreadPool(uint32_t threadCount = std::thread::hardware_concurrency());
 
    ~ThreadPool();
 
    template <typename F, typename... Args>
    auto Enqueue(F&& f, Args&&... args);
 
    void Wait();
 
    const std::vector<std::thread>& GetWorkers() const
    {
        return workers_;
    }
 
private:
    std::vector<std::thread> workers_;
    std::queue<std::function<void()>> tasks_;
 
    std::mutex queue_mutex_;
    std::condition_variable condition_;
    std::condition_variable drained_;
    uint32_t active_tasks_ = 0;
    bool stop_ = false;
};
 
template <typename F, typename... Args>
auto ThreadPool::Enqueue(F&& f, Args&&... args)
{
    using ReturnType = std::invoke_result_t<F, Args...>;
 
    auto task = std::make_shared<std::packaged_task<ReturnType()>>(std::bind(std::forward<F>(f), std::forward<Args>(args)...));
    auto result = task->get_future();
    {
        std::unique_lock lock(queue_mutex_);
        if (stop_)
        {
            throw std::runtime_error("Enqueue called on a stopped ThreadPool");
        }
 
        tasks_.emplace([task]() { (*task)(); });
    }
    condition_.notify_one();
    return result;
}
} // namespace pixelbullet