Пул потоков thread

#include <iostream>
#include <thread>
#include <vector>
#include <mutex>
 
#include <functional>
#include <queue>
#include <windows.h>
#include <stdio.h>
using namespace std;
 
 
class thread_pool
{
    vector<thread> th;
    vector<bool> statusTH;
    unsigned int id;
    unsigned int countthreads;
    queue <function<void()>> qWork;
    atomic_bool done;
    bool run;
    mutex mtx;
    function<void()> task;
    void WORK(unsigned int i) // основная функция для получения и исполнения работы потоком
    {
        //Sleep(2000);
        while (!done)
        {
            if (run && getJob())
            {
                task();
            }
            else
            {
                run = false;
                statusTH[i] = (false);
                this_thread::yield();
                if (!done)
                {
                    cout << "ОЖИДАНИЕ -> " << this_thread::get_id() << endl;
                    SuspendThread(th[i].native_handle());
                } 
                //Sleep(1000);
            }
            
        }
 
 
    }
 
public:
    bool getJob() // метод проверяющий очередь работ, и если она не пустая извлекает из нее работу
    {
        lock_guard <mutex> lockG(mtx);
        if (!qWork.empty())
        {
            cout << "DONE1 -> " << this_thread::get_id() << "   " << qWork.size() << endl;
            task = move(qWork.front());
            //task = qWork.front();    <-Альтернатива
            qWork.pop();
            return true;
        }
        else
        {
            done = true; //при выполнении завершает все потоки, пул не переходит в состояние ожидания новых работ
            return false;
        }
    }
    thread_pool() // конструктор
    {
        run = false;
        countthreads = thread::hardware_concurrency();
        if (countthreads == 0)
        {
            countthreads = 1;
        }
        for (unsigned int i = 0; i < countthreads; i++)
        {
            th.push_back(thread(&thread_pool::WORK, this ,i));
            statusTH.push_back(true);
        }
    }
    ~thread_pool() //деструктор, в котором присоединяются потоки к меин потоку
    {
        done = false;
        cout << "Деструктор" <<  endl;
        for (unsigned int i = 0; i < countthreads; i++)
        {
            if (th[i].joinable())
            {
                th[i].join();
            }
        }
    }
    void AddWorkInQueue(function<void()> Fun) //метод для добавления работ в очередь
    {
        lock_guard <mutex> lockG(mtx);
        qWork.push(Fun);
    }
    void startJob()//метод для старта потоков в пуле, для обработки очереди работ
    {
        run = true;
        for (unsigned int i = 0; i < countthreads; i++)
        {
            if (!statusTH[i])
            {
                statusTH[i] = true;
                ResumeThread(th[i].native_handle());
            }
        }
    }
};
void DoWork() // простенькая функция, для тестов
{
    cout << "РАБОТА -> " << this_thread::get_id() << endl;
    //this_thread::sleep_for(chrono::milliseconds(100));
}
 
int main() {
    setlocale(LC_ALL, "Russian");
 
    thread_pool t1;
 
    Sleep(2000);
   
    for (int i = 0; i < 1000; i++)
    {
        t1.AddWorkInQueue(DoWork);
    }
    Sleep(2000);
    t1.startJob();
    return 0;
}

class thread_pool
{
    vector<thread> th;
    vector<bool> statusTH;
    unsigned int id;
    unsigned int countthreads;
    queue <function<void()>> qWork;
//  Я хочу использовать, std::atomic_boolпотому что хочу иметь логическое значение,
//  к которому должны обращаться разные потоки.
    //atomic_bool done;
    atomic<bool>done;
    bool run;
    mutex mtx;

#include <iostream>
#include <thread>
#include <vector>
#include <mutex>
 
#include <functional>
#include <queue>
//#include <windows.h>
#include <atomic>
#include <stdio.h>
using namespace std;
 
 
class thread_pool
{
    vector<thread> th;
    unsigned int countthreads;
    queue <function<void()>> qWork;
    atomic<bool> done;
    mutex mtx;
    function<void()> task;
    void WORK(unsigned int i) // основная функция для получения и исполнения работы потоком
    {
        while (!done)
        {
            if (getJob())
            {
                task();
            }
            else
            {
                this_thread::sleep_for(chrono::milliseconds(1000));
                this_thread::yield();
            }
        }
    }
 
public:
    bool getJob() // метод проверяющий очередь работ, и если она не пустая извлекает из нее работу
    {
        lock_guard <mutex> lockG(mtx);
        if (!qWork.empty())
        {
            cout << "DONE1 -> " << this_thread::get_id() << "   " << qWork.size() << endl;
            task = move(qWork.front());
            qWork.pop();
            return true;
        }
        else
        {
            done = true; //при выполнении завершает все потоки, пул не переходит в состояние ожидания новых работ
            return false;
        }
    }
    thread_pool() // конструктор
    {
        countthreads = thread::hardware_concurrency();
        if (countthreads == 0)
        {
            countthreads = 1;
        }
        for (unsigned int i = 0; i < countthreads; i++)
        {
            th.push_back(thread(&thread_pool::WORK, this, i));
        }
    }
    ~thread_pool() //деструктор, в котором присоединяются потоки к меин потоку
    {
        done = false;
        for (unsigned int i = 0; i < countthreads; i++)
        {
            if (th[i].joinable())
            {
                th[i].join();
            }
        }
    }
    void AddWorkInQueue(function<void()> Fun) //метод для добавления работ в очередь
    {
        lock_guard <mutex> lockG(mtx);
        qWork.push(Fun);
    }
};
void DoWork() // простенькая функция, для тестов
{
    cout << "РАБОТА -> " << this_thread::get_id() << endl;
    this_thread::sleep_for(chrono::milliseconds(100));
}
 
int main() {
    setlocale(LC_ALL, "Russian");
 
    thread_pool t1;
    //Sleep(2000);
 
    for (int i = 0; i < 100; i++)
    {
        t1.AddWorkInQueue(DoWork);
    }
    return 0;
}

// this_thread::yield example
#include <iostream>       // std::cout
#include <thread>         // std::thread, std::this_thread::yield
#include <atomic>         // std::atomic
 
std::atomic<bool> ready(false);
 
void count1m(int id) {
    while (!ready) std::this_thread::yield(); // подождите, пока main() не будет готов...(ждать)
        
for (volatile// компилятор не будет оптимизировать эту переменную
        int i = 0; i<10000000; ++i) {}
    std::cout << id<< " *";
}
 
 
 
//============================
int main()
{
    std::thread threads[10];
    std::cout << "race of 10 threads that count to 1 million:\n";
    for (int i = 0; i<10; ++i) threads[i] = std::thread(count1m, i);// Десять потоков делает
    ready = true;               // go!
    
    for (auto& th : threads) th.join();//Пробка <=============
    std::cout << '\n';
 
    getchar();
    return 0;
}