Created
May 11, 2020 15:21
-
-
Save supercairos/2893684c639610f04f67658780182c8b to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#ifndef THREAD_POOL_H | |
#define THREAD_POOL_H | |
#include <vector> | |
#include <queue> | |
#include <memory> | |
#include <thread> | |
#include <mutex> | |
#include <condition_variable> | |
#include <future> | |
#include <functional> | |
#include <stdexcept> | |
class ThreadPool { | |
public: | |
ThreadPool(size_t); | |
template<class F, class... Args> | |
auto enqueue(F&& f, Args&&... args) | |
-> std::future<typename std::invoke_result<F, Args...>::type>; | |
~ThreadPool(); | |
private: | |
// 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; | |
}; | |
// the constructor just launches some amount of workers | |
inline ThreadPool::ThreadPool(size_t threads) | |
: stop(false) | |
{ | |
for(size_t i = 0;i<threads;++i) | |
workers.emplace_back( | |
[this] | |
{ | |
for(;;) | |
{ | |
std::function<void()> task; | |
{ | |
std::unique_lock<std::mutex> lock(this->queue_mutex); | |
this->condition.wait(lock, | |
[this]{ return this->stop || !this->tasks.empty(); }); | |
if(this->stop && this->tasks.empty()) | |
return; | |
task = std::move(this->tasks.front()); | |
this->tasks.pop(); | |
} | |
task(); | |
} | |
} | |
); | |
} | |
// add new work item to the pool | |
template<class F, class... Args> | |
auto ThreadPool::enqueue(F&& f, Args&&... args) | |
-> std::future<typename std::invoke_result<F, Args...>::type> | |
{ | |
using return_type = typename std::invoke_result<F, Args...>::type; | |
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); | |
// don't allow enqueueing after stopping the pool | |
if(stop) | |
throw std::runtime_error("enqueue on stopped ThreadPool"); | |
tasks.emplace([task](){ (*task)(); }); | |
} | |
condition.notify_one(); | |
return res; | |
} | |
// the destructor joins all threads | |
inline ThreadPool::~ThreadPool() | |
{ | |
{ | |
std::unique_lock<std::mutex> lock(queue_mutex); | |
stop = true; | |
} | |
condition.notify_all(); | |
for(std::thread &worker: workers) | |
worker.join(); | |
} | |
#endif |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment