线程池

#include <thread>
#include <iostream>
#include <atomic>
#include <mutex>
#include <condition_variable>
#include <memory>
#include <queue>
#include <functional>
#include <unistd.h>
class ThreadPool
{
private:
    std::mutex mutex_lock;
    std::condition_variable conditionVal;
    std::atomic_bool isClose;
    std::queue<std::function<void()>> taskQueue;
    int num;

public:
    ThreadPool(int num);
    ~ThreadPool();
    void start();

    template<typename F>
    void addTask(F&& task);
};

ThreadPool::ThreadPool(int num_)
{
    num = num_;
    isClose = false;
}

ThreadPool::~ThreadPool()
{
    isClose = true;
    conditionVal.notify_all();
}

void ThreadPool::start()
{
    for (int i = 0; i < num; i++)
    {
        std::thread([this](){
            //造一个锁  这个锁只是下面用来阻塞自己而已
            std::unique_lock<std::mutex> lock(mutex_lock);
            lock.unlock();
            while(true){
                conditionVal.wait(lock);
                if(!taskQueue.empty()){
                    auto task = std::move(taskQueue.front());
                    taskQueue.pop();
                    mutex_lock.unlock();
                    task();
                }

                mutex_lock.unlock();
                if(isClose){
                    break;
                }

                // 看看关了没有
                if(isClose){
                    mutex_lock.unlock();
                    break;
                }
                // 如果任务队列为空 就阻塞 阻塞前先上锁
                mutex_lock.lock();
                
                if(taskQueue.empty()){
                    std::cout<<std::this_thread::get_id()<<"阻塞\n";
                    conditionVal.wait(lock);
                    mutex_lock.unlock();
                    std::cout<<std::this_thread::get_id()<<"被唤醒\n";
                }
                else {
                    auto task = std::move(taskQueue.front());
                    taskQueue.pop();
                    mutex_lock.unlock();
                    task();
                }
            }

            std::cout<<std::this_thread::get_id()<<"退出\n";
        }).detach();
    }
}

template<typename F>
inline void ThreadPool::addTask(F&& task)
{   
    {
        std::lock_guard<std::mutex> lock(mutex_lock);
        taskQueue.emplace(std::forward<F>(task));
    }
    conditionVal.notify_one();
}