ThreadPool.hpp

#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 m_Workers;
        }
 
    private:
        std::vector<std::thread> m_Workers;
        std::queue<std::function<void()>> m_Tasks;
 
        std::mutex m_QueueMutex;
        std::condition_variable m_Condition;
        bool m_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(m_QueueMutex);
            if (m_Stop)
            {
                throw std::runtime_error("Enqueue called on a stopped ThreadPool");
            }
 
            m_Tasks.emplace([task]() { (*task)(); });
        }
        m_Condition.notify_one();
        return result;
    }
} // namespace PixelBullet