c++11 线程池 实现，已部署~~

每日一歌，分享好心情： 卡斯特梅的雨季

c++11 实现的线程池，项目已用，Lets go
用到了很多c11的语法，大家一起学习

#ifndef _THREAD_POOL_HPP_
#define _THREAD_POOL_HPP_

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

class ThreadPool {
public:
    ThreadPool(int num_threads = 4);
    ThreadPool(const ThreadPool&) = delete;
    ThreadPool() = delete;
    ThreadPool& operator=(const ThreadPool&) = delete;
    ThreadPool& operator=(ThreadPool&&) = delete;

    
    template   
    auto AddTask(F&& f, Args&&... args) -> std::future;  

    ~ThreadPool();

private:
    std::vector _worker_threads;           
    bool _stop = false;                                 
    std::queue> _tasks_queue;     
    std::mutex _task_queue_mutex;                       
    std::condition_variable _condition;                 
};

ThreadPool::ThreadPool(int num_threads) 
    : _stop(false) {
    if (num_threads < 1) {
        throw std::runtime_error("ThreadPool: num_threads less than one");
    }

    
    for (int i=0; i
        _worker_threads.emplace_back(
            std::thread(
                [this]{
                    while(true) {
                        std::function task; 
                        {
                            std::unique_lock lock(this->_task_queue_mutex);     
                            
                            this->_condition.wait(lock, [this]{return this->_stop || !this->_tasks_queue.empty(); });
                            if (this->_stop && this->_tasks_queue.empty()) return;
                            task = std::move(this->_tasks_queue.front());
                            this->_tasks_queue.pop();
                        }
                        
                        task();
                    }
                }
            )
        );
    }
}

ThreadPool::~ThreadPool() {
    {
        std::unique_lock lock(_task_queue_mutex);
        _stop = true;
    }
    
    _condition.notify_all();
    for (std::thread &worker : _worker_threads) {
        worker.join();
    }
}


template 
auto ThreadPool::AddTask(F&&f, Args&&...args) -> std::future {
    using return_type = decltype(f(args...));
    
    auto task_ptr = std::make_shared>(
        std::bind(std::forward(f), std::forward(args)...));
    
    
    std::function warpper_func = [task_ptr]() { (*task_ptr)(); };
    {
        std::unique_lock lock(_task_queue_mutex);
        if (_stop) {
            throw std::runtime_error("ThreadPool is Stopped!");
        }
        _tasks_queue.emplace(warpper_func);
    }
    
    _condition.notify_one();

    
    return task_ptr->get_future();
}


#endif

#include "threadpool.hpp"
#include 
#include 
#include 
using namespace std;


int main(int argc, char* argv[]) {
    
    int pool_size = 5;
    int task_num = 6;

    ThreadPool threadpool(pool_size);
    vector> resVec;
    
    for (int i=0; i
        resVec.emplace_back(
            threadpool.AddTask(
                [i] {
                    cout << "hello " << endl;
                    this_thread::sleep_for(chrono::seconds(1));
                    return i;
                }
            )
        );
    }

    
    for (auto&& result: resVec) {
        cout << result.get() << " ";
    }
    cout << endl;

    return  0;
}