c++实现简单的线程池

    线程池，先创建一定数目的线程，初始都处于空闲状态。当有新的任务进来，从线程池中取出一个空闲的线程处理任务，处理完成之后，该线程被重新放回到线程池中。当线程池中的线程都在处理任务时，若有新的任务产生，只能等待，直到线程池中有线程结束任务空闲才能执行。

   用c++实现固定线程数的线程池。

#include <mutex>
#include <condition_variable>
#include <functional>
#include <queue>
#include <thread>

namespace GraphicUtility
{
    class FixedThreadPool 
    {
    public:
        explicit FixedThreadPool(size_t threadCount)
            : _data(std::make_shared<data>())
        {
            for (size_t i = 0; i < threadCount; ++i) 
            {
                std::thread([data = _data] 
                {
                    std::unique_lock<std::mutex> guard(data->_mutex);
                    for (;;) 
                    {
                        if (!data->_tasks.empty())
                        {
                            std::function<void()> currentTask = std::move(data->_tasks.front());
                            data->_tasks.pop();
                            guard.unlock();
                            currentTask();
                            guard.lock();
                        }
                        else if (data->_isShutdown)
                        {
                            break;
                        }
                        else 
                        {
                            data->_condition.wait(guard);
                        }
                    }
                }).detach();
            }
        }

        FixedThreadPool() = default;
        FixedThreadPool(FixedThreadPool&&) = default;

        ~FixedThreadPool() 
        {
            if ((bool)_data) 
            {
                {
                    std::lock_guard<std::mutex> guard(_data->_mutex);
                    _data->_isShutdown = true;
                }
                _data->_condition.notify_all();
            }
        }

        template <class F>
        void execute(F&& task) 
        {
            {
                std::lock_guard<std::mutex> guard(_data->_mutex);
                _data->_tasks.emplace(std::forward<F>(task));
            }
            _data->_condition.notify_one();
        }

    private:
        struct data
        {
            std::mutex _mutex;
            std::condition_variable _condition;
            bool _isShutdown = false;
            std::queue<std::function<void()>> _tasks;
        };
        std::shared_ptr<data> _data;
    };

   测试

#include<iostream>

void printTest()
{
    std::cout << "Thread start id = " << std::this_thread::get_id() << std::endl;
}

int main()
{ 
    FixedThreadPool p(4);         //有4个线程的线程池
    for (int i = 0; i < 10; i++)  //初始化10个任务
    {
        p.execute(printTest);    //打印执行任务的线程的id
    }
    getchar();
    return 0;
}

 运行结果