proxygen::WorkerThread Class Reference

#include <WorkerThread.h>

Inheritance diagram for proxygen::WorkerThread:

Public Member Functions
	WorkerThread (folly::EventBaseManager *ebm, const std::string &evbName=std::string())
virtual	~WorkerThread ()
void	start ()
void	stopWhenIdle ()
void	forceStop ()
void	wait ()
folly::EventBase *	getEventBase ()
std::thread::native_handle_type	getThreadNativeHandle () noexcept
std::thread::id	getThreadId () const noexcept

Static Public Member Functions
static WorkerThread *	getCurrentWorkerThread ()

Protected Member Functions
virtual void	setup ()
virtual void	cleanup ()

Private Types
enum	State : uint8_t {   State::IDLE, State::STARTING, State::RUNNING, State::STOP_WHEN_IDLE,   State::FORCE_STOP }

Private Member Functions
	WorkerThread (WorkerThread const &)=delete
WorkerThread &	operator= (WorkerThread const &)=delete
void	runLoop ()

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

Static Private Attributes
static FOLLY_TLS WorkerThread *	currentWorker_ = nullptr

Detailed Description

A WorkerThread represents an independent event loop that runs in its own thread.

Definition at line 29 of file WorkerThread.h.

Member Enumeration Documentation

enum proxygen::WorkerThread::State : uint8_t

strongprivate

Enumerator
IDLE
STARTING
RUNNING
STOP_WHEN_IDLE
FORCE_STOP

Definition at line 120 of file WorkerThread.h.

                   : 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
  };

Constructor & Destructor Documentation

proxygen::WorkerThread::WorkerThread ( folly::EventBaseManager *  ebm, const std::string &  evbName = std::string()  )

explicit

Definition at line 22 of file WorkerThread.cpp.

References eventBase_, and folly::EventBase::setName().

    : eventBaseManager_(eventBaseManager) {
  // Only set the event base name if not empty.
  // While not ideal, this preserves the previous program name inheritance
  // behavior.
  if (!evbName.empty()) {
    eventBase_.setName(evbName);
  }
}

proxygen::WorkerThread::~WorkerThread ( )

virtual

Definition at line 33 of file WorkerThread.cpp.

References IDLE, and state_.

                            {
  CHECK(state_ == State::IDLE);
}

proxygen::WorkerThread::WorkerThread ( WorkerThread const &  )

privatedelete

Member Function Documentation

void proxygen::WorkerThread::cleanup ( )

protectedvirtual

Reimplemented in proxygen::RequestWorker.

Definition at line 127 of file WorkerThread.cpp.

References folly::EventBaseManager::clearEventBase(), currentWorker_, and eventBaseManager_.

Referenced by proxygen::RequestWorker::cleanup(), and start().

                           {
  currentWorker_ = nullptr;
  if (eventBaseManager_) {
    eventBaseManager_->clearEventBase();
  }
}

void proxygen::WorkerThread::forceStop

(

)

Request that the worker stop executing as soon as possible.

This will terminate the worker thread's event loop, and cause the thread to return. If there are any services still running in the worker thread, their events will no longer be processed.

This function is asynchronous: it signals the worker thread to stop, and returns without waiting for the thread to actually terminate. The wait() method must be called to wait for the thread to terminate.

Definition at line 73 of file WorkerThread.cpp.

References eventBase_, FORCE_STOP, IDLE, folly::EventBase::runInEventBaseThread(), RUNNING, state_, STOP_WHEN_IDLE, and folly::EventBase::terminateLoopSoon().

                             {
  // Call runInEventBaseThread() to perform all of the work in the actual
  // worker thread.
  //
  // This way we don't have to synchronize access to state_.
  eventBase_.runInEventBaseThread([this] {
    if (state_ == State::RUNNING || state_ == State::STOP_WHEN_IDLE) {
      state_ = State::FORCE_STOP;
      eventBase_.terminateLoopSoon();
    // state_ could be IDLE if we don't execute this callback until the
    // EventBase is destroyed in the WorkerThread destructor
    } else if (state_ != State::IDLE) {
      LOG(FATAL) << "forceStop() called in unexpected state " <<
          static_cast<int>(state_);
    }
  });
}

static WorkerThread* proxygen::WorkerThread::getCurrentWorkerThread ( )

inlinestatic

Get the current WorkerThread running this thread.

Returns nullptr if called from a thread that is not running inside WorkerThread.

Definition at line 111 of file WorkerThread.h.

References folly::ssl::cleanup().

Referenced by proxygen::RequestWorker::getRequestWorker().

                                                {
    return currentWorker_;
  }

folly::EventBase* proxygen::WorkerThread::getEventBase ( )

inline

Get the EventBase used to drive the events in this worker thread.

Definition at line 85 of file WorkerThread.h.

Referenced by proxygen::RequestWorker::flushStats().

                                 {
    return &eventBase_;
  }

std::thread::id proxygen::WorkerThread::getThreadId ( ) const

inlinenoexcept

Get ID of the underlying thread objects (valid only when the thread is running).

Definition at line 101 of file WorkerThread.h.

                                           {
    return thread_.get_id();
  }

std::thread::native_handle_type proxygen::WorkerThread::getThreadNativeHandle ( )

inlinenoexcept

Get native handle of the underlying thread object (valid only when the thread is running).

Definition at line 93 of file WorkerThread.h.

                                                               {
    return thread_.native_handle();
  }

WorkerThread& proxygen::WorkerThread::operator= ( WorkerThread const &  )

privatedelete

void proxygen::WorkerThread::runLoop ( )

private

Definition at line 134 of file WorkerThread.cpp.

References eventBase_, FORCE_STOP, IDLE, folly::EventBase::loop(), folly::EventBase::loopForever(), RUNNING, STARTING, state_, and STOP_WHEN_IDLE.

Referenced by start().

                           {
  // Update state_
  CHECK(state_ == State::STARTING);
  state_ = State::RUNNING;

  VLOG(1) << "WorkerThread " << this << " starting";

  // Call loopForever().  This will only return after stopWhenIdle() or
  // forceStop() has been called.
  eventBase_.loopForever();

  if (state_ == State::STOP_WHEN_IDLE) {
    // We have been asked to stop when there are no more events left.
    // Call loop() to finish processing events.  This will return when there
    // are no more events to process, or after forceStop() has been called.
    VLOG(1) << "WorkerThread " << this << " finishing non-internal events";
    eventBase_.loop();
  }

  CHECK(state_ == State::STOP_WHEN_IDLE || state_ == State::FORCE_STOP);
  state_ = State::IDLE;

  VLOG(1) << "WorkerThread " << this << " terminated";
}

void proxygen::WorkerThread::setup ( )

protectedvirtual

Reimplemented in proxygen::RequestWorker.

Definition at line 98 of file WorkerThread.cpp.

References currentWorker_, eventBase_, eventBaseManager_, and folly::EventBaseManager::setEventBase().

Referenced by proxygen::RequestWorker::setup(), and start().

                         {
#ifndef _MSC_VER
  sigset_t ss;

  // Ignore some signals
  sigemptyset(&ss);
  sigaddset(&ss, SIGHUP);
  sigaddset(&ss, SIGINT);
  sigaddset(&ss, SIGQUIT);
  sigaddset(&ss, SIGUSR1);
  sigaddset(&ss, SIGUSR2);
  sigaddset(&ss, SIGPIPE);
  sigaddset(&ss, SIGALRM);
  sigaddset(&ss, SIGTERM);
  sigaddset(&ss, SIGCHLD);
  sigaddset(&ss, SIGIO);
  PCHECK(pthread_sigmask(SIG_BLOCK, &ss, nullptr) == 0);
#endif

  // Update the currentWorker_ thread-local pointer
  CHECK(nullptr == currentWorker_);
  currentWorker_ = this;

  // Update the manager with the event base this worker runs on
  if (eventBaseManager_) {
    eventBaseManager_->setEventBase(&eventBase_, false);
  }
}

void proxygen::WorkerThread::start

(

)

Begin execution of the worker.

This starts the worker thread, and returns immediately.

Definition at line 37 of file WorkerThread.cpp.

References cleanup(), eventBase_, folly::gen::guard(), IDLE, joinLock_, runLoop(), setup(), STARTING, state_, thread_, and folly::EventBase::waitUntilRunning().

                         {
  CHECK(state_ == State::IDLE);
  state_ = State::STARTING;

  {
    // because you could theoretically call wait in parallel with start,
    // why are you in such a hurry anyways?
    std::lock_guard<std::mutex> guard(joinLock_);
    thread_ = std::thread([&]() mutable {
        this->setup();
        this->runLoop();
        this->cleanup();
      });
  }
  eventBase_.waitUntilRunning();
  // The server has been set up and is now in the loop implementation
}

void proxygen::WorkerThread::stopWhenIdle

(

)

Request that the worker thread stop when there are no more events to process.

Normally each worker thread runs forever, even if it is idle with no events to process. This function requests that the worker thread return when it becomes idle.

This is used for graceful shutdown: Once the services have been asked to shutdown, stopWhenIdle() can be called on the WorkerThread so that it will return as soon as the services in this thread no longer have any events to process.

Typically you will still want to call forceStop() after a timeout, in case some of the services take too long to shut down gracefully.

Definition at line 55 of file WorkerThread.cpp.

References eventBase_, IDLE, folly::EventBase::runInEventBaseThread(), RUNNING, state_, STOP_WHEN_IDLE, and folly::EventBase::terminateLoopSoon().

                                {
  // Call runInEventBaseThread() to perform all of the work in the actual
  // worker thread.
  //
  // This way we don't have to synchronize access to state_.
  eventBase_.runInEventBaseThread([this] {
    if (state_ == State::RUNNING) {
      state_ = State::STOP_WHEN_IDLE;
      eventBase_.terminateLoopSoon();
    // state_ could be IDLE if we don't execute this callback until the
    // EventBase is destroyed in the WorkerThread destructor
    } else if (state_ != State::IDLE && state_ != State::STOP_WHEN_IDLE) {
      LOG(FATAL) << "stopWhenIdle() called in unexpected state " <<
          static_cast<int>(state_);
    }
  });
}

void proxygen::WorkerThread::wait

(

)

Synchronously wait for termination of the worker thread.

Note that the worker thread will only terminate after stopWhenIdle() or forceStop() has been called, so you typically should only call wait() after first using one of these functions.

Definition at line 91 of file WorkerThread.cpp.

References folly::gen::guard(), joinLock_, and thread_.

                        {
  std::lock_guard<std::mutex> guard(joinLock_);
  if (thread_.joinable()) {
    thread_.join();
  }
}

Member Data Documentation

FOLLY_TLS WorkerThread * proxygen::WorkerThread::currentWorker_ = nullptr

staticprivate

Definition at line 141 of file WorkerThread.h.

Referenced by cleanup(), and setup().

folly::EventBase proxygen::WorkerThread::eventBase_

private

Definition at line 137 of file WorkerThread.h.

Referenced by forceStop(), runLoop(), setup(), start(), stopWhenIdle(), and WorkerThread().

folly::EventBaseManager* proxygen::WorkerThread::eventBaseManager_ {nullptr}

private

Definition at line 138 of file WorkerThread.h.

Referenced by cleanup(), and setup().

std::mutex proxygen::WorkerThread::joinLock_

private

Definition at line 136 of file WorkerThread.h.

Referenced by start(), and wait().

State proxygen::WorkerThread::state_ {State::IDLE}

private

Definition at line 134 of file WorkerThread.h.

Referenced by forceStop(), runLoop(), start(), stopWhenIdle(), and ~WorkerThread().

std::thread proxygen::WorkerThread::thread_

private

Definition at line 135 of file WorkerThread.h.

Referenced by start(), and wait().

---

The documentation for this class was generated from the following files:

• proxygen/lib/services/WorkerThread.h
• proxygen/lib/services/WorkerThread.cpp