ExecutorService.h

Go to the documentation of this file.

#ifndef LOGGING_EXECUTORSERVICE_H
#define LOGGING_EXECUTORSERVICE_H
 
#include <atomic>
#include <functional>
#include <future>
#include <mutex>
#include <queue>
#include <thread>
#include <type_traits>
 
namespace lintel {
class ExecutorService
{
private:
  std::atomic<bool> m_exit = false;
  std::mutex m_mutex;
  std::condition_variable m_conditionVariable;
  typedef std::function<void()> TASK;
  std::queue<TASK> m_tasks;
  std::thread m_runnable;
 
  void run();
 
public:
  ExecutorService() : m_runnable([&]() { run(); }) {}
 
  ~ExecutorService()
  {
    {
      // m_exit must be flipped under the mutex the worker's predicate reads under,
      // otherwise the notify_all() can slip into the window between the predicate
      // check and the wait, and the join() below hangs forever.
      std::lock_guard<std::mutex> lock(m_mutex);
      m_exit = true;
    }
    m_conditionVariable.notify_all();
    m_runnable.join();
  }
 
  template<class F, class... Args>
  std::future<typename std::invoke_result<typename std::decay<F>::type, typename std::decay<Args>::type...>::type>
    execute(F &&f, Args &&...args);
};
 
template<class F, class... Args>
std::future<typename std::invoke_result<typename std::decay<F>::type, typename std::decay<Args>::type...>::type>
  ExecutorService::execute(F &&f, Args &&...args)
{
  auto func = std::make_shared<std::packaged_task<
    typename std::invoke_result<typename std::decay<F>::type, typename std::decay<Args>::type...>::type()>>(
    std::bind(std::forward<F>(f), std::forward<Args>(args)...));
  auto future = func->get_future();
  {
    std::unique_lock<std::mutex> lock(m_mutex);
    m_tasks.push([=, func = std::move(func)]() { (*func)(); });
  }
  m_conditionVariable.notify_one();
  return future;
}
 
}// namespace lintel
#endif// LOGGING_EXECUTORSERVICE_H