C++ thread pool implementation

#include <vector>
#include <queue>
#include <future>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <stdexcept>

class ThreadPool 
{
public:
    //Constructor: Create worker threads based on the number of threads entered (default hardware concurrency).    //Each worker thread executes a loop, constantly extracting and executing tasks from the task queue.    //Explicat keyword prevents implicit type conversion    explicit ThreadPool(size_t threads = std::thread::hardware_concurrency())
        : stop(false) 
    {
        if (threads == 0) 
        {
            threads = 1;
        }

        for (size_t i = 0; i < threads; ++i) 
        {
            workers.emplace_back([this] 
            {
                for (;;) 
                {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(this->queue_mutex);
                        
                        //Waiting condition: The thread waits for the task to arrive or stop signal through the condition variable.  (CPU usage: close to 0% during sleep, wake up only when the task arrives)                        //The lambda expression is used as a predicate. When the condition (stop signal is true or the task queue is not empty) is true, the blocking will be unblocked.                        this->(lock, [this] {
                            return (this->stop || !this->());
                            });

                        /* Traditional busy waiting: while (!(stop || !())) {} // Empty loop consumes CPU */

                        if (this->stop && this->())
                        {
                            //If the thread pool needs to be terminated and the task queue is empty, return directly                            return;
                        }

                        //Task extraction: Take out the task from the queue and execute it, and use std::move to avoid copy overhead.                        task = std::move(this->());
                        this->();
                    }
                    //Execute tasks                    task();
                }
            });
        }
    }

    //Task Submission (enqueue method)    template<class F, class... Args>
    auto enqueue(F&& f, Args&&... args)
        -> std::future<typename std::result_of<F(Args...)>::type> 
    {
        using return_type = typename std::result_of<F(Args...)>::type;

        //Task encapsulation: Use std::packaged_task to wrap user tasks, support asynchronous return of results.        //Intelligent pointer management: shared_ptr ensures that the life cycle of the task object continues until execution is completed.        //Perfect forwarding: Keep the lvalue/rvalue characteristics of the parameter through std::forward.        auto task = std::make_shared<std::packaged_task<return_type()>>(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
            );

        std::future<return_type> res = task->get_future();
        {
            std::unique_lock<std::mutex> lock(queue_mutex);

            if (stop)
            {
                throw std::runtime_error("enqueue on stopped ThreadPool");
            }  

            ([task]() { (*task)(); });
            /* The object passed in push needs to be constructed in advance, and then copied to insert it into the container;
                Emplace can construct an object using the parameters required by the constructor and insert it directly into the container.
                Compared with push, emplace saves the copying step, using emplace will save more memory.  */
        }
        condition.notify_one();
        return res;
    }

    ~ThreadPool() 
    {
        //Set the stop flag, wake up all threads, and wait for the task queue to be cleared.        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread& worker : workers)
        {
            ();
        }
    }

private:
    std::vector<std::thread> workers;        //Storing worker thread object    std::queue<std::function<void()>> tasks; //Task queue, storing tasks to be executed
    std::mutex queue_mutex;                  //Protect the mutex lock of the task queue    std::condition_variable condition;       //Condition variables for synchronization between threads    bool stop;                               //Sign whether the thread pool stops};

std::vector<std::thread> workers;        // Worker thread containerstd::queue<std::function<void()>> tasks; // Task queuestd::mutex queue_mutex;                  // Queue mutex lockstd::condition_variable condition;       // Conditional variablesbool stop;                               // Stop sign

explicit ThreadPool(size_t threads = std::thread::hardware_concurrency())
    : stop(false)
{
    if (threads == 0) 
    {
        threads = 1;
    }
        
    for (size_t i = 0; i < threads; ++i) 
    {
        workers.emplace_back([this] { /* Worker thread logic */ });
    }
}

for (;;)
{
    std::function<void()> task;
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        (lock, [this] {
            return stop || !();
        });

        if (stop && ()) 
        {
           return; 
        }

        task = std::move(());
        ();
    }
    task();
}

template<class F, class... Args>
auto enqueue(F&& f, Args&&... args)
    -> std::future<typename std::result_of<F(Args...)>::type>

auto task = std::make_shared<std::packaged_task<return_type()>>
    (std::bind(std::forward<F>(f), std::forward<Args>(args)...));

([task]() { (*task)(); });

~ThreadPool() 
{
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        stop = true;
    }
    condition.notify_all();
    for (auto& worker : workers)
    {
        ();
    }  
}

std::bind(std::forward<F>(f), std::forward<Args>(args)...)

         [Task Submitter]
             |
             v
       [packaged_task] <---- shared_ptr ---- [Task Queue]
             |
             v
         [future]

void adjust_workers(size_t new_size) 
{
    if (new_size > ()) 
    {
     	// Scaling logic    } 
    else 
    {
        // Scaling logic    }
}

using Task = std::pair<int, std::function<void()>>; // Priority + Task   std::priority_queue<Task> tasks;

moodycamel::ConcurrentQueue<std::function<void()>> tasks;

#include <iostream>

int main() 
{
    ThreadPool pool(4);
    
    // Submit normal functions    auto future1 = ([](int a, int b) {
        return a + b;
    }, 2, 3);
    
    // Submit member functions    struct Calculator 
    {
        int multiply(int a, int b) 
        { 
            return a * b; 
        }
    } calc;
    auto future2 = (std::bind(&Calculator::multiply, &calc, 
                                        std::placeholders::_1, 
                                        std::placeholders::_2), 4, 5);
    
    //Exception handling example    auto future3 = ([]() -> int {
        throw std::runtime_error("example error");
        return 1;
    });
    
    std::cout << "2+3=" << () << std::endl;
    std::cout << "4*5=" << () << std::endl;
    
    try 
    {
        ();
    } 
    catch(const std::exception& e)
    {
        std::cout << "Caught exception: " << () << std::endl;
    }
    
    return 0;
}