基于C++11特性的线程池

#define POOLNUM 5
#include<vector>
#include <queue>
#include <mutex>
#include <thread>
#include <functional>
#include <condition_variable>
#include <iostream>
    class ThreadPool
    {
    private:
        std::vector<std::thread> Threads; // 线程池
        std::queue<std::function<void()>> tasks;
        std::condition_variable condition;
        bool stop;
    private:
        static ThreadPool* instance;
        static std::mutex mtx;
        ThreadPool(int numThreads) : stop(false)
        {
            for (int i = 0; i < numThreads; i++)
            {
                Threads.emplace_back([this]
                    {
                        while (1) {
                            std::unique_lock<std::mutex> lock(mtx);
                            condition.wait(lock, [this] {
                                //任务队列为空或者线程停止
                                return !tasks.empty() || stop;
                                });
                            if (stop && tasks.empty()) {
                                return;
                            }
                            //取任务
                            std::function<void()> task(std::move(tasks.front()));
                            tasks.pop();
                            lock.unlock();
                            //处理任务
                            task();
                        } 
                    });
            }
        }
        
        ~ThreadPool()
        {
            {
                std::unique_lock<std::mutex> lock(mtx);
                stop = true;
            }
            condition.notify_all();
            for (auto& t : Threads)
            {
                t.join();
            }
        }
       

    public:
        static ThreadPool* GetInstance()
        {
            if (instance == NULL)
            { // 二次检测防止锁冲突
                mtx.lock();
                if (instance == NULL)
                {
                    instance = new ThreadPool(POOLNUM);
                }
                mtx.unlock();
            }
            return instance;
        }
        template <class A, class... Args>
        void push(A&& a, Args &&...args)
        {
            std::function<void()> task =
                std::bind(std::forward<A>(a), std::forward<Args>(args)...);
            {
                std::unique_lock<std::mutex> lock(mtx);
                tasks.emplace(move(task));
            }
            condition.notify_one(); // 唤醒线程
        }
    };
    ThreadPool* ThreadPool::instance = NULL;
    std::mutex ThreadPool::mtx;