c++11,線程池之二--有等待線程池中任務完成功能的線程池

#include <deque>
#include <future>
#include <memory>
#include <functional>
#include <iostream>
#include <iostream>

class function_wrapper
{
    struct impl_base {
        virtual void call()=0;
        virtual ~impl_base() {}
    };
    std::unique_ptr<impl_base> impl;
    template<typename F>
    struct impl_type: impl_base
    {
        F f;
        impl_type(F&& f_): f(std::move(f_)) {}
        void call() { f(); }
    };
public:
    template<typename F>
    function_wrapper(F&& f):
        impl(new impl_type<F>(std::move(f)))
    {}

    void call() { impl->call(); }

    function_wrapper(function_wrapper&& other):
        impl(std::move(other.impl))
    {}

    function_wrapper& operator=(function_wrapper&& other)
    {
        impl=std::move(other.impl);
        return *this;
    }

    function_wrapper(const function_wrapper&)=delete;
    function_wrapper(function_wrapper&)=delete;
    function_wrapper& operator=(const function_wrapper&)=delete;
};

class thread_pool
{
public:
    std::deque<function_wrapper> work_queue;

    template<typename FunctionType>
    std::future<typename std::result_of<FunctionType()>::type>
    submit(FunctionType f)
    {
        typedef typename std::result_of<FunctionType()>::type result_type;
        
        std::packaged_task<result_type()> task(std::move(f));
        std::future<result_type> res(task.get_future());
        work_queue.push_back(std::move(task));
        return res;
    }
   public:  
    thread_pool():  
        joiner(threads)  
    {  
        done.store(false);  
        unsigned const thread_count=std::thread::hardware_concurrency();  
        try  
        {  
            for(unsigned i=0;i<thread_count;++i)  
            {  
                threads.push_back(  
                    std::thread(&thread_pool::worker_thread,this));  
            }  
        }  
        catch(...)  
        {  
            done=true;  
            throw;  
        }  
    }  
  
    ~thread_pool()  
    {  
        done=true;  
    }  
  
    template<typename FunctionType>  
    void submit(FunctionType f)  
    {  
        work_queue.push(std::function<void()>(f));  
    }  

};