C++11 线程池的使用

#ifndef THREADPOOL_H
#define THREADPOOL_H
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

class CThreadPool
{
    using Task = std::function;
private:
    CThreadPool();
    ~CThreadPool();
    CThreadPool(const CThreadPool&) = delete;
    CThreadPool& operator=(const CThreadPool&) = delete;
public:
    static CThreadPool& GetInstance();

    void SetMaxThreadNum(const int iCount);

    void OnStart();

    void OnStop();

    void AppendTask(const Task& _task);

private:
    void DoWork();

private:
    std::atomic_bool m_bIsRunning{false};
    unsigned short m_usThreadNum{2};
    std::vector m_vctThreads;
    std::queue m_queTasks;
    std::condition_variable m_cv;
    std::mutex m_mtx;
};



#endif 

#include "../include/threadpool.h"
CThreadPool::CThreadPool()
{

}
CThreadPool::~CThreadPool()
{
    OnStop();
}

CThreadPool& CThreadPool::GetInstance()
{
    static CThreadPool instance;
    return instance;
}

void CThreadPool::SetMaxThreadNum(const int _iCount)
{
    m_usThreadNum = _iCount;
}

void CThreadPool::OnStart()
{
    m_bIsRunning = true;
    
    for (int iIndex = 0; iIndex < m_usThreadNum; ++iIndex)
    {
        m_vctThreads.emplace_back(std::thread(&CThreadPool::DoWork, this));
    }
}

void CThreadPool::OnStop()
{
    {
        std::unique_lock ulock(m_mtx);
        m_bIsRunning = false;
        m_cv.notify_all();
    }
    for (auto& td : m_vctThreads)
    {
        if (td.joinable())
        {
            td.join();
        }
    }
}

void CThreadPool::AppendTask(const Task& _task)
{
    std::unique_lock ulock(m_mtx);
    m_queTasks.push(_task);
    m_cv.notify_one();
}

void CThreadPool::DoWork()
{
    while(m_bIsRunning)
    {
        Task task;
        {
            std::unique_lock ulock(m_mtx);
            if (!m_queTasks.empty())
            {
                task = m_queTasks.front();
                m_queTasks.pop();
            }
            else if (m_queTasks.empty() && m_bIsRunning)
            {
                m_cv.wait(ulock);
            }
        }

        if (task)
        {
            std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
            task();
            std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();

            std::cout << (std::chrono::time_point_cast(end) - 
                  std::chrono::time_point_cast(start)).count() /1000000.00<< std::endl; 
        }
        
    }
}

#include "include/threadpool.h"

std::mutex mtx;
void Test(int iValue)
{
    std::unique_lock ulock(mtx);
    std::cout<