c++实现简单的线程池

╰+攻爆jí腚メ 2023-06-30 02:42 17阅读 0赞

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

用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;
    }

运行结果

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpeWF6aGVuMjAxMQ_size_16_color_FFFFFF_t_70][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpeWF6aGVuMjAxMQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200114164330204.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpeWF6aGVuMjAxMQ==,size_16,color_FFFFFF,t_70