threading.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "readerwriterqueue.h"
#include "blockingconcurrentqueue.h"
 
// External Includes
#include <functional>
#include <thread>
#include <vector>
 
namespace nap
{
    class TaskQueue final
    {
    public:
        // a task in the queue is a function object
        using Task = std::function<void()>;
 
    public:
        TaskQueue(int maxQueueItems = 20);
        bool enqueue(Task task) { return mQueue.enqueue(task); }
 
        void processBlocking();
 
        void process();
 
    private:
        moodycamel::BlockingReaderWriterQueue<Task> mQueue;
        std::vector<Task> mDequeuedTasks;
    };
 
 
    class WorkerThread
    {
    public:
        WorkerThread();
 
        WorkerThread(bool blocking, int maxQueueItems = 20);
        virtual ~WorkerThread();
 
        void enqueue(TaskQueue::Task task) { mTaskQueue.enqueue(task); }
 
        void start();
 
        void stop();
 
        bool isRunning() { return mRunning; }
 
        virtual void loop() { }
 
    private:
        std::unique_ptr<std::thread> mThread = nullptr;
        std::atomic<bool> mRunning;
        bool mBlocking = true;
        TaskQueue mTaskQueue;
    };
 
 
    class ThreadPool final
    {
    public:
        ThreadPool(int numberOfThreads = 1, int maxQueueItems = 20, bool realTimePriority = false);
        ~ThreadPool();
 
        void execute(TaskQueue::Task task) {
            assert(task != nullptr);
            mTaskQueue.enqueue(task);
        }
 
        void shutDown();
 
        void resize(int numberOfThreads);
 
        int getThreadCount() const { return int(mThreads.size()); }
 
        int getTaskCount() const { return mTaskQueue.size_approx(); }
 
        bool isStopping() const { return (mStop == true); }
 
    private:
        void addThread();
 
        std::vector<std::thread> mThreads;
        std::atomic<bool> mStop;
        moodycamel::BlockingConcurrentQueue<TaskQueue::Task> mTaskQueue;
        bool mRealTimePriority = false;
    };
}