Thread Pool Code

#include<bits/stdc++.h>
#include<thread>
#include<mutex>
#include<windows.h>
using namespace std;
#define b(a,x) Beep(a,x)
#define tttt 1600
#define ttt 1200
#define tt 800
#define t 400
#define t_ 200
#define t__ 100
#define t___ 50
#define n1 262
#define n1_ 277
#define n2 294
#define n2_ 311
#define n3 330
#define n4 349
#define n4_ 370
#define n5 392
#define n5_ 415
#define n6 440
#define n6_ 466
#define n7 494
#define no1 523
#define no1_ 554
#define no2 587
#define no2_ 622
#define no3 659
#define no4 698
#define no4_ 740
#define no5 784
#define no5_ 831
#define no6 880
#define no6_ 932
#define no7 988
#define noo1 1046
#define noo1_ 1109
#define noo2 1175
#define noo2_ 1245
#define noo3 1319
#define noo4 1397
#define noo4_ 1480
#define noo5 1568
#define noo5_ 1661
#define noo6 1760
#define noo6_ 1865
#define noo7 1976
mutex mtx;
void A(int x){
    for(int i=1;i<=x;i++){
        lock_guard<mutex> lock(mtx);
        cout<<i<<" a\n";
    }
}
void B(int x){
    for(int i=1;i<=x;i++){
        lock_guard<mutex> lock(mtx);
        cout<<i<<" b\n";
    }
}
int main(){
    thread Ath(A,6);
    thread Bth(B,8);
    Ath.join();
    Bth.join();
    cout<<"OK!\n";
    return 0;
}

#ifndef THREAD_POOL_H
#define THREAD_POOL_H\
#include<bits/stdc++.h>
#include<vector>
#include<queue>
#include<windows.h>
#include<thread>
#include<mutex>
#include<condition_variable>
#include<functional>
#include<future>
class thread_pool{
    public:
        thread_pool(size_t);
        template<class F,class... Args>
        auto enqueue(F&& f,Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type>;
        ~thread_pool();
    private:
        std::vector<std::thread> workers;
        std::queue<std::function<void()> > tasks;
        std::mutex queue_mutex;
        std::condition_variable condition;
        bool stop;
};
#include "thread_pool.tpp"
#endif

template<class F,class... Args>
auto thread_pool::enqueue(F&& f,Args&&...args) -> std::future<typename std::result_of<F(Args...)>::type> {
    using return_type=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)...)
    );
    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 thread_pool");
        tasks.emplace([task](){(*task)();});
    }
    condition.notify_one();
    return res;
}

#include "thread_pool.h"
thread_pool::thread_pool(size_t threads)
    :stop(false){
    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);
                        this->condition.wait(true,
                            [this]{return this->stop||!this->tasks.empty();});
                        if(this->stop&&this->tasks.empty())
                            return;
                        task=std::(this->tasks.front());
                        this->tasks.pop();
                    }
                    task();
                }
            }
        );
}
thread_pool::~thread_pool(){
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        stop=true;
    }
    condition.nofity_all();
    for(std::thread &worker:workers)
        worker.join();
}