ThreadPool.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Threading/Threading.h"
 
namespace SC
{
struct SC_THREADING_EXPORT ThreadPool;
 
struct SC_THREADING_EXPORT ThreadPoolTask
{
 
    Function<void()> function; 
 
    Function<void()> afterRelease;
 
  private:
    friend struct ThreadPool;
    ThreadPool*     threadPool = nullptr;
    ThreadPoolTask* next       = nullptr;
};
 
struct SC_THREADING_EXPORT ThreadPool
{
    using Task = ThreadPoolTask;
 
    ThreadPool() = default;
    ~ThreadPool() { (void)destroy(); }
 
    ResultThreading create(size_t workerThreads);
 
    ResultThreading destroy();
 
    ResultThreading queueTask(Task& task);
 
    ResultThreading waitForAllTasks();
 
    ResultThreading waitForTask(Task& task);
 
  private:
    Task* taskHead = nullptr; // Head of the FIFO linked list containing all threads
    Task* taskTail = nullptr; // Tail of the FIFO linked list containing all threads
 
    size_t numRunningTasks  = 0; // How many tasks are running in this moment
    size_t numWorkerThreads = 0; // How many worker threads exist in this pool (== 0 means uninitialized threadpool)
 
    Mutex             poolMutex;     // Protects all ThreadPool members access from worker threads
    ConditionVariable taskAvailable; // Signals to worker threads that there is a new queued task available
    ConditionVariable taskCompleted; // Signals to threadpool that there is a new task that was completed
 
    bool stopRequested = false; // Signals background threads to end their infinite task processing loop
 
    struct WorkerThread;
};
 
} // namespace SC