Class Thread

be/src/util/thread.h:50–200

Thin wrapper around boost::thread that can register itself with the singleton ThreadMgr (a private class implemented in thread.cc entirely, which tracks all live threads so that they may be monitored via the debug webpages). This class has a limited subset of boost::thread's API. Construction is almost the same, but clients must supply a category and a name for each thread so that they can be iden

//
/// TODO: Consider allowing fragment IDs as category parameters.
class Thread {
 public:
  /// This static Create method pattern mimics that in the boost::thread constructors.
  /// There is one static Create method for each number of arguments that the thread
  /// function accepts. To extend the set of acceptable signatures, add
  /// another static Create method with <class F, class A1.... class An>.
  //
  /// In general:
  ///  - category: string identifying the thread category to which this thread belongs,
  ///    used for organising threads together on the debug UI.
  ///  - name: name of this thread. Will be appended with "-<thread-id>" to ensure
  ///    uniqueness.
  ///  - F - a method type that supports operator(), and the instance passed to the
  ///    constructor is executed immediately in a separate thread.
  ///  - A1...An - argument types whose instances are passed to f(...)
  ///  - thread - unique_ptr<Thread>* to reset with the created Thread.
  ///  - fault_injection_eligible - If set to true, allow fault injection at this
  ///    callsite (see thread_creation_fault_injection). If set to false, fault
  ///    injection is diabled at this callsite. Thread creation sites that crash
  ///    Impala or abort startup must have this set to false.
  template <class F>
  static Status Create(const std::string& category, const std::string& name,
      const F& f, std::unique_ptr<Thread>* thread,
      bool fault_injection_eligible = false) {
    return StartThread(category, name, f, thread, fault_injection_eligible);
  }

  template <class F, class A1>
  static Status Create(const std::string& category, const std::string& name,
      const F& f, const A1& a1, std::unique_ptr<Thread>* thread,
      bool fault_injection_eligible = false) {
    return StartThread(category, name, boost::bind(f, a1), thread,
        fault_injection_eligible);
  }

  template <class F, class A1, class A2>
  static Status Create(const std::string& category, const std::string& name,
      const F& f, const A1& a1, const A2& a2, std::unique_ptr<Thread>* thread,
      bool fault_injection_eligible = false) {
    return StartThread(category, name, boost::bind(f, a1, a2), thread,
        fault_injection_eligible);
  }

  template <class F, class A1, class A2, class A3>
  static Status Create(const std::string& category, const std::string& name,
      const F& f, const A1& a1, const A2& a2, const A3& a3,
      std::unique_ptr<Thread>* thread, bool fault_injection_eligible = false) {
    return StartThread(category, name, boost::bind(f, a1, a2, a3), thread,
        fault_injection_eligible);
  }

  template <class F, class A1, class A2, class A3, class A4>
  static Status Create(const std::string& category, const std::string& name,
      const F& f, const A1& a1, const A2& a2, const A3& a3, const A4& a4,
      std::unique_ptr<Thread>* thread, bool fault_injection_eligible = false) {
    return StartThread(category, name, boost::bind(f, a1, a2, a3, a4), thread,
        fault_injection_eligible);
  }