threadpool.h

Go to the documentation of this file.

 
#pragma once
 
#include <thread>
#include <functional>
#include <type_traits>
#include <promeki/core/namespace.h>
#include <promeki/core/error.h>
#include <promeki/core/mutex.h>
#include <promeki/core/waitcondition.h>
#include <promeki/core/future.h>
#include <promeki/core/list.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class ThreadPool {
        public:
                ThreadPool(int threadCount = -1);
 
                ~ThreadPool();
 
                ThreadPool(const ThreadPool &) = delete;
                ThreadPool &operator=(const ThreadPool &) = delete;
                ThreadPool(ThreadPool &&) = delete;
                ThreadPool &operator=(ThreadPool &&) = delete;
 
                template <typename F>
                auto submit(F &&callable) -> Future<std::invoke_result_t<F>> {
                        using R = std::invoke_result_t<F>;
                        auto task = std::make_shared<std::packaged_task<R()>>(
                                std::forward<F>(callable));
                        Future<R> fut(task->get_future());
                        bool runInline = false;
                        {
                                Mutex::Locker locker(_mutex);
                                if(_threadCount == 0) {
                                        runInline = true;
                                } else {
                                        _tasks.pushToBack([task]() { (*task)(); });
                                        _cv.wakeOne();
                                }
                        }
                        if(runInline) (*task)();
                        return fut;
                }
 
                void setThreadCount(int count);
 
                int threadCount() const;
 
                int activeThreadCount() const;
 
                void waitForDone();
 
                Error waitForDone(unsigned int timeoutMs);
 
                void clear();
 
        private:
                using Task = std::function<void()>;
 
                void workerFunc();
                void spawnThreads(int count);
 
                mutable Mutex           _mutex;
                WaitCondition           _cv;
                WaitCondition           _doneCv;
                List<Task>              _tasks;
                List<std::thread>       _threads;
                int                     _threadCount = 0;
                int                     _activeCount = 0;
                bool                    _shutdown = false;
};
 
PROMEKI_NAMESPACE_END