ThreadPool(size_t);

template<class F, class... Args>

auto enqueue(F&& f, Args&&... args)

-> std::future<typename std::result_of<F(Args...)>::type>;

~ThreadPool();

// need to keep track of threads so we can join them

std::vector< std::thread > workers;

// the task queue

std::queue< std::function<void()> > tasks;

// synchronization

std::mutex queue_mutex;

std::condition_variable condition;

bool stop;

: stop(false)

{

for(size_t i = 0;i<threads;++i)

workers.emplace_back(

[this]

{

while(true)

{

std::unique_lock<std::mutex> lock(this->queue_mutex);

while(!this->stop && this->tasks.empty())

this->condition.wait(lock);

if(this->stop && this->tasks.empty())

return;

std::function<void()> task(this->tasks.front());

this->tasks.pop();

lock.unlock();

task();

}

}

);

-> std::future<typename std::result_of<F(Args...)>::type>

{

typedef typename std::result_of<F(Args...)>::type return_type;

// don't allow enqueueing after stopping the pool

if(stop)

throw std::runtime_error("enqueue on stopped ThreadPool");

auto task = std::make_shared< std::packaged_task<return_type()> >(

std::bind(std::forward<F>(f), std::forward<Args>(args)...)

);

std::future<return_type> res = task->get_future();

{

std::unique_lock<std::mutex> lock(queue_mutex);

tasks.push([task](){ (*task)(); });

}

condition.notify_one();

return res;