ThreadPool.h

Go to the documentation of this file.

/*
 * ThreadPool.h
 *
 * Copyright (c) 2024 saker
 *
 * This file is part of LMMS - https://lmms.io
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program (see COPYING); if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301 USA.
 *
 */
 
#ifndef LMMS_THREAD_POOL_H
#define LMMS_THREAD_POOL_H
 
#include <atomic>
#include <queue>
#include <tuple>
#include <type_traits>
#include <vector>
 
#include <condition_variable>
#include <future>
#include <mutex>
#include <thread>
 
namespace lmms {
class ThreadPool
{
public:
        ~ThreadPool();

        template <typename Fn, typename... Args>
        auto enqueue(Fn&& fn, Args&&... args) -> std::future<std::invoke_result_t<Fn, Args...>>
        {
                using ReturnType = std::invoke_result_t<Fn, Args...>;
 
                auto promise = std::make_shared<std::promise<ReturnType>>();
                auto task = [promise, fn = std::forward<Fn>(fn), args = std::make_tuple(std::forward<Args>(args)...)] 
                {
                        if constexpr (!std::is_same_v<ReturnType, void>)
                        {
                                promise->set_value(std::apply(fn, args));
                                return;
                        }
                        std::apply(fn, args);
                        promise->set_value();
                };
 
                {
                        const auto lock = std::unique_lock{m_runMutex};
                        m_queue.push(std::move(task));
                }
 
                m_runCond.notify_one();
                return promise->get_future();
        }

        auto numWorkers() const -> size_t;

        static auto instance() -> ThreadPool&;
 
private:
        ThreadPool(size_t numWorkers);
        void run();
        std::vector<std::thread> m_workers;
        std::queue<std::function<void()>> m_queue;
        std::atomic<bool> m_done = false;
        std::condition_variable m_runCond;
        std::mutex m_runMutex;
        inline static size_t s_numWorkers = std::thread::hardware_concurrency();
};
} // namespace lmms
 
#endif // LMMS_THREAD_POOL_H