WorkerThread.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef __WORKER_THREAD_H_
#define __WORKER_THREAD_H_
 
#include <atomic>
#include <mutex>
#include <thread>
 
namespace Utils {

template <class ThreadsPool, class Job> class WorkerThread {
public:
  explicit WorkerThread(ThreadsPool *threadsPool)
      : threadsPool(threadsPool), StopFlag(false) {
    Thread = std::thread(&WorkerThread::Run, this);
  }

  ~WorkerThread() { Stop(); }

  void Start() {
    if (Thread.joinable())
      return;
 
    {
      std::lock_guard lock(threadsPool->Mutex);
      StopFlag = false;
    }
    Thread = std::thread(&WorkerThread::Run, this);
  }

  void Stop() {
    if (!Thread.joinable())
      return;
 
    {
      std::lock_guard lock(threadsPool->Mutex);
 
      StopFlag = true;
    }
 
    Join();
  }

  void SetStopUnlocked() { StopFlag = true; }

  inline void Join() {
    if (Thread.joinable())
      Thread.join();
  }
 
private:
  inline bool TerminateWait() const {
    return threadsPool->HasWork() || StopFlag;
  }

  void Run() {
    for (;;) {
      std::unique_lock lock(threadsPool->Mutex);
      if (!TerminateWait())
        threadsPool->Condition.wait(lock, [this] { return TerminateWait(); });
 
      while (threadsPool->HasWork() && !StopFlag) {
        const std::shared_ptr<Job> job =
            std::move(threadsPool->JobsQueue.front());
        threadsPool->JobsQueue.pop();
        lock.unlock();
 
        job->DoWork();
 
        {
          std::lock_guard lockCount(threadsPool->FinishMutex);
          threadsPool->FinishCount += job->GetJobCount();
        }
        lock.lock();
      }
 
      if (StopFlag)
        break;
      lock.unlock();
      threadsPool->NotifyFinish();
    }
  }
 
  ThreadsPool
      *threadsPool;   
  std::thread Thread; 
  bool StopFlag; 
};
 
} // namespace Utils
 
#endif // !__WORKER_THREAD_H_