# Thread

## class Thread

class `paddle::``Thread`

  A simple wrapper for std::thread

  Subclassed by paddle::SocketServer, paddle::SocketWorker, paddle::ThreadWorker

  Public Functions

  `Thread`()

    Construct Function. Default thread pointer is null.

  virtual `~Thread`()
  void `start`()

    Creat a new thread and call run() function.

  void `detach`()

    Detach the thread. It don’t need to be waited until it finish.

  void `join`()

    Join the thread. It should be waited until it finish.

  virtual void `run`() = 0

    Define what to be done on this thread through override this function.

  Protected Attributes

  std::unique_ptr<std::thread> `thread_`

## class ThreadWorker

class `paddle::``ThreadWorker`

  ThreadWorker maintains a job queue. It executes the jobs in the job queue sequentianlly in a separate thread.

  Use addJob() to add a new job to the job queue.

  Inherits from paddle::Thread

  Public Types

  typedef std::function<void()> `JobFunc`

  Public Functions

  `ThreadWorker`()

    Construct Function. Default size of job queue is 0 and not stopping.

  `~ThreadWorker`()

    Destruct Function. If it’s running, wait until all job finish and then stop it.

  void `stop`()

    Finish current running job and quit the thread.

  void `addJob`( JobFunc func)

    Add a new job to the job queue.

  void `wait`()

    Wait until all jobs was done (the job queue was empty).

  Protected Functions

  virtual void `run`()

    Execute jobs in the job queue sequentianlly,.

    Note
      If finish all the jobs in the job queue, notifies all the waiting threads the job queue was empty.

  Protected Attributes

  Queue<JobFunc> `jobs_`
  bool `stopping_`
  LockedCondition `finishCV_`
  bool `empty_`

## class SyncThreadPool

class `paddle::``SyncThreadPool`

  SyncThreadPool maintains a pool of threads. It executes the job use all workers in the pool.

  Use exec() to run a new job, job complete when exec returned. Only one job can exec simultaneously.

  Each worker has an tid whose range is [0, getNumThreads()). JobFunc can use tid to divide input data.

  Public Types

  typedef std::function<void(int tid, size_t numThreads)> `JobFunc`

  Public Functions

  `SyncThreadPool`()

    Construct Function. No thread will be created.

  `SyncThreadPool`(size_t numWorkers, bool checkOwner = true)

    Construct Fucntion. Create numWorkers of threads in the pool.

    Parameters
      - `numWorkers`: Number of the workers in the pool.
      - `checkOwner`: Default true. If checkOwner is true, this sync thread pool should be used by it’s owner thread.
  `~SyncThreadPool`()
  size_t `getNumThreads`()

    Return num of threads in the pool.

  void `exec`( JobFunc jobFunc, JobFunc ownerFunc = nullptr)

    Execute a job using all the theads in the pool.

    Note
      For the ownerFunc, tid=getNumThreads().
    Parameters
      - `jobFunc`: The function to be executed.
      - `ownerFunc`: Owner thread can do something in owerFunc when job executing.
  void `execPlusOwner`( JobFunc jobFunc)

    Execute a job using all the threads in the pool. And the owner thread will do the same job.

    Note
      Assume that JobFunc will execute numThread + 1 times, with tid ranging [0,numThread]. The thread whose tid is numThread is the owner thread.
    Parameters
      - `jobFunc`: The job to be executed.

  Public Static Functions

  static void `execHelper`( SyncThreadPool *pool, JobFunc jobFunc)

    Execute a job if has pool, else use caller thread as a worker.

    Parameters
      - `pool`: The pool to execute the job.
      - `jobFunc`: The job to be excuted.

  Protected Functions

  void `start`()

    Start all the workers in the pool, call their run() function.

  void `stop`()

    Stop all the workers in the pool.

  void `run`(int tid)

    Execute the jobFunc_ using the worker thread tid, if not stopping.

  Protected Attributes

  pid_t `ownerThreadId_`
  bool `stopping_`
  ThreadBarrier `jobStartBarrier_`
  ThreadBarrier `jobFinishBarrier_`
  JobFunc `jobFunc_`
  bool `checkOwner_`
  std::vector<std::unique_ptr<std::thread>> `workers_`

## class MultiThreadWorker

template <class T>
class `paddle::``MultiThreadWorker`

  MultiThreadWorker maintains a job queue and a result queue. It executes the jobs in the job queue and puts the results into the result queue sequentially in multi separate threads.

  Add jobs:

  Use addJob() to add a new job to the job queue (the user added jobs should not return nullptr).

  Use stopAddJob() to stop adding new jobs to the job queue (addJob() can not be called after stopAddJob()).

  Normal stop:

  Use waitResult() to get the results until nullptr is returned. Use stop() to exit normally (stopAddJob() should be called first).

  Force stop:

  Use forceStop() to exit forcibly even though there are remaining jobs in the job queue.

  Public Types

  typedef T `ResultType`
  typedef std::shared_ptr<ResultType> `ResultPtrType`
  typedef std::function<ResultPtrType ()> `JobFunc`

  Public Functions

  `MultiThreadWorker`(size_t workerNum, size_t queueCapacity)

    Construct Function. Initialize the multithread worker.

    Parameters
      - `workerNum`: Number of the workers.
      - `queueCapacity`: Capapcity of the result queue.
  virtual `~MultiThreadWorker`()

    Destruct Function. Force stop the workers even though there are remaining jobs in the job queue.

  void `stop`()

    Stop all the workers normally.

    Note
      stopAddJob() should be called before it.
  void `forceStop`()

    Stop all the workers forcibly.

    Note
      This function will call stopAddJob() first and empty the result queue.
  void `addJob`( JobFunc func)

    Add a job to the job queue.

    Note
      Job can not be added after calling stopAddJob().
  void `stopAddJob`()

    Stop adding new jobs to the job queue.

    Note
      This fuction enqueue a return nullptr function to the job queue.
  ResultPtrType `waitResult`()

    Dequeue the first result in the result queue and return it.

    Note
      If the result queue is empty, wait until it’s not empty or return nullptr if all the results have been returned.
  bool `testResult`()

    The result queue is empty or not.

    Return
      true if empty.

  Protected Functions

  virtual void `run`()

    Do the jobs in the job queue sequentianlly and enqueue the result into the result queue.

    Note
      A nullptr will be enqueued into the resulte queue, when a worker finished.

  Protected Attributes

  bool `stopping_`
  bool `jobAdding_`
  size_t `nullResultNum_`
  Queue<JobFunc> `jobs_`
  BlockingQueue<ResultPtrType> `results_`
  std::vector<std::unique_ptr<std::thread>> `workers_`

## class AsyncThreadPool

class `paddle::``AsyncThreadPool`

  AsyncThreadPool maintains a job queue and threads pool. It executes the jobs from queue asynchronously.

  Add jobs:

  Use addJob() to add a new job to the job queue and get a std::future result. The caller’s thread continues running. Call std::future::get() when the result’s value is needed, and the caller’s thread may be blocked until thread-pool finished the job.

  Use addBatchJobs() to add a batch of jobs. Unlike addJob()‘s asynchronization, addBatchJobs will block caller’s thread until all jobs in the batch are finished.

  Stop: Use stop() to stop the thread pool. Job can be added once stopped.

  Process-wide Singleton: Use AsyncThreadPool::ProcessChannel(N) first to create N threads. Then call AsyncThreadPool::ProcessChannel() to get the process-wide global thread pool.

  Public Types

  typedef std::function<void()> `JobFunc`

  Public Functions

  `AsyncThreadPool`()
  `AsyncThreadPool`(size_t threadNum)

    Construct Function. Install all the workers.

    Parameters
      - `threadNum`: Number of the threads, must greater than 1.
  `~AsyncThreadPool`()
  void `stop`()

    Stop all the workers normally.

  template <class F, class... Args>
  auto `addJob`(F &&f, Args&&... args)

    Add a job to queue and return a std::future.

    Note
      The job will be executed asynchronously. Call std::future::get() when the execturation result is needed;
  template <class F>
  void `addBatchJobs`(const std::vector<F> &jobs, std::vector<typename std::result_of<F()>::type> &results)

    Add a batch of jobs to the queue. The main thread will be blocked until these jobs are finished. The results will be stored in `results` according to `jobs` order.

    Note
      results may need to be carefully cleared before addBatchJobs().
    Template Parameters
      - `F`: should have a return value.
    Parameters
      - `jobs`: a vector of executable objection.
      - `results`: a vector to store the results.
  template <class F>
  void `addBatchJobs`(const std::vector<F> &jobs)

    Add a batch of jobs reguardless of its result.

    Template Parameters
      - `F`: don’t need to have a return value.
    Parameters
      - `jobs`: a vector of executable objection.

  Public Static Functions

  static AsyncThreadPool &`ProcessChannel`(size_t initThreadNum = 0)

    A process-wide singleton. Used as a global thread pool It should be initialized by calling AsyncThreadPool::ProcessChannel(N) first to create N threads, then call AsyncThreadPool::ProcessChannel() will get the thread pool.

  Protected Functions

  void `run`()

    Execute the jobs in the job queue.