WorkerThread.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2015-present, Facebook, Inc.
 *  All rights reserved.
 *
 *  This source code is licensed under the BSD-style license found in the
 *  LICENSE file in the root directory of this source tree. An additional grant
 *  of patent rights can be found in the PATENTS file in the same directory.
 *
 */
#pragma once

#include <atomic>
#include <cstdint>
#include <folly/Portability.h>
#include <folly/io/async/EventBase.h>
#include <mutex>
#include <thread>

namespace folly {
class EventBaseManager;
}

namespace proxygen {

class WorkerThread {
 public:
  explicit WorkerThread(
    folly::EventBaseManager* ebm, const std::string& evbName = std::string());
  virtual ~WorkerThread();

  void start();

  void stopWhenIdle();

  void forceStop();

  void wait();

  folly::EventBase* getEventBase() {
    return &eventBase_;
  }

  std::thread::native_handle_type getThreadNativeHandle() noexcept {
    return thread_.native_handle();
  }

  std::thread::id getThreadId() const noexcept {
    return thread_.get_id();
  }

  static WorkerThread* getCurrentWorkerThread() {
    return currentWorker_;
  }

 protected:
  virtual void setup();
  virtual void cleanup();

 private:
  enum class State : uint8_t {
    IDLE,           // Not yet started
    STARTING,       // start() called, thread not fully started yet
    RUNNING,        // Thread running normally
    STOP_WHEN_IDLE, // stopWhenIdle() called, not stopped yet
    FORCE_STOP,     // forceStop() called, but the loop is still cleaning up
  };

  // Forbidden copy constructor and assignment operator
  WorkerThread(WorkerThread const &) = delete;
  WorkerThread& operator=(WorkerThread const &) = delete;

  void runLoop();

  State state_{State::IDLE};
  std::thread thread_;
  std::mutex joinLock_;
  folly::EventBase eventBase_;
  folly::EventBaseManager* eventBaseManager_{nullptr};

  // A thread-local pointer to the current WorkerThread for this thread
  static FOLLY_TLS WorkerThread* currentWorker_;
};

} // proxygen