问C++ STD线程池

EN

#pragma once

#include <memory>
#include <queue>
#include <thread>
#include <mutex>
#include <shared_mutex>
#include <condition_variable>

#include "../Worker/Worker.h"

class Tasker
{

public:

    //  Default Tasker Constructor.
    Tasker(const unsigned int & newTaskerThreadCount)
    {
        //  Construct the Vector of Threads. By default, each of these will not have any thread associated.
        mTaskerThreads = std::vector<std::thread>(newTaskerThreadCount);
    }


    //  Default Tasker Destructor, waits for all the workers to complete.
    virtual ~Tasker()
    {
        end();
    }


    //  Add Worker to the List of Workers to Execute.
    inline virtual void addWorker(std::shared_ptr<Worker> newWorker)
    {
        //  Create a unique lock.
        std::unique_lock<std::mutex> lockWorkers(mWorkersMutex);

        //  Add a worker.
        mWorkers.push(newWorker);

        //  Release the lock.
        lockWorkers.release();

        //  Notify all waiting threads.
        mWorkersCB.notify_all();
    }


    //  Begin executing any workers in the queue.
    inline virtual void begin()
    {
        //  
        mIsActive = true;

        //  Create all the Threads.
        for (unsigned int i = 0; i < mTaskerThreads.size(); i++)
        {
            mTaskerThreads[i] = std::thread(&Tasker::executeWorker, this);
        }
    }


    //  End the execution, waiting for all the workers in the queue to complete.
    inline virtual void end()
    {
        //  
        mIsEnd = true;

        //  Create a unique lock.
        std::unique_lock<std::mutex> lockWorkers(mWorkersMutex);

        //  Wait forever.
        while (true)
        {
            //  Lock the Workers.
            if (!lockWorkers.owns_lock())
            {
                lockWorkers.lock();
            }

            //  Check if all the work is finished.
            if (mWorkers.size() == 0)
            {
                //  Wait for all the threads to finish.
                for (unsigned int i = 0; i < mTaskerThreads.size(); i++)
                {
                    //  Wait for a thread to finish.
                    mTaskerThreads[i].join();
                }
            }

            //  Unlock the Workers Mutex.
            lockWorkers.release();
        }

        //  No longer active.
        mIsActive = false;

        //  No longer end.
        mIsEnd = false;
    }





private:

    //  Execute the Work on a Thread.
    inline virtual void executeWorker()
    {
        //  Create a unique lock.
        std::unique_lock<std::mutex> lockWorkers(mWorkersMutex);

        //  
        while (true)
        {
            //  Lock the Workers.
            if (!lockWorkers.owns_lock())
            {
                lockWorkers.lock();
            }

            //  Check if we have any work.
            if (mWorkers.size() > 0)
            {
                //  Get the first available work.
                std::shared_ptr<Worker> worker = mWorkers.front();

                //  Remove it from the queue.
                mWorkers.pop();

                //  Release the lock.
                lockWorkers.release();

                //  Execute the Work.
                if (worker != nullptr)
                {
                    worker->executeWork();
                }
            }
            else
            {
                //  
                if (mIsEnd)
                {
                    //  Release the lock.
                    lockWorkers.release();

                    //  Break.
                    break;
                }
                else
                {
                    //  Release the lock and wait.
                    mWorkersCB.wait(lockWorkers);
                }
            }
        }
    }


    //  The Vector of Tasker Threads.
    std::vector<std::thread> mTaskerThreads;

    //  The Mutex for the Vector of Workers.
    std::mutex mWorkersMutex;

    //  The Vector of Work Assignments.
    std::queue<std::shared_ptr<Worker>> mWorkers;

    //  Whether or not the Tasker is active.
    std::atomic_bool mIsActive = false;

    //  Whether or not the Tasker is ending.
    std::atomic_bool mIsEnd = false;

    //  Condition Variable the Workers wait on.
    std::condition_variable mWorkersCB;

};

#pragma once

class Worker
{

public:

    //  Default Worker Constructor.
    Worker() = default;

    //  Default Worker Destructor.
    virtual ~Worker() = default;

    //  Execute the Work. 
    virtual void executeWork() = 0;


private:


};