diff options
Diffstat (limited to 'base/threading/simple_thread.h')
-rw-r--r-- | base/threading/simple_thread.h | 60 |
1 files changed, 33 insertions, 27 deletions
diff --git a/base/threading/simple_thread.h b/base/threading/simple_thread.h index 3deeb1018c..f9f5e91045 100644 --- a/base/threading/simple_thread.h +++ b/base/threading/simple_thread.h @@ -48,6 +48,7 @@ #include "base/base_export.h" #include "base/compiler_specific.h" +#include "base/macros.h" #include "base/synchronization/lock.h" #include "base/synchronization/waitable_event.h" #include "base/threading/platform_thread.h" @@ -58,25 +59,26 @@ namespace base { // virtual Run method, or you can use the DelegateSimpleThread interface. class BASE_EXPORT SimpleThread : public PlatformThread::Delegate { public: - class BASE_EXPORT Options { + struct BASE_EXPORT Options { public: - Options() : stack_size_(0), priority_(ThreadPriority::NORMAL) {} - explicit Options(ThreadPriority priority) - : stack_size_(0), priority_(priority) {} - ~Options() {} + Options() = default; + explicit Options(ThreadPriority priority_in) : priority(priority_in) {} + ~Options() = default; - // We use the standard compiler-supplied copy constructor. + // Allow copies. + Options(const Options& other) = default; + Options& operator=(const Options& other) = default; // A custom stack size, or 0 for the system default. - void set_stack_size(size_t size) { stack_size_ = size; } - size_t stack_size() const { return stack_size_; } - - // A custom thread priority. - void set_priority(ThreadPriority priority) { priority_ = priority; } - ThreadPriority priority() const { return priority_; } - private: - size_t stack_size_; - ThreadPriority priority_; + size_t stack_size = 0; + + ThreadPriority priority = ThreadPriority::NORMAL; + + // If false, the underlying thread's PlatformThreadHandle will not be kept + // around and as such the SimpleThread instance will not be Join()able and + // must not be deleted before Run() is invoked. After that, it's up to + // the subclass to determine when it is safe to delete itself. + bool joinable = true; }; // Create a SimpleThread. |options| should be used to manage any specific @@ -94,19 +96,13 @@ class BASE_EXPORT SimpleThread : public PlatformThread::Delegate { // Subclasses should override the Run method. virtual void Run() = 0; - // Return the thread name prefix, or "unnamed" if none was supplied. - std::string name_prefix() { return name_prefix_; } - - // Return the completed name including TID, only valid after Start(). - std::string name() { return name_; } - // Return the thread id, only valid after Start(). PlatformThreadId tid() { return tid_; } // Return True if Start() has ever been called. bool HasBeenStarted(); - // Return True if Join() has evern been called. + // Return True if Join() has ever been called. bool HasBeenJoined() { return joined_; } // Overridden from PlatformThread::Delegate: @@ -116,18 +112,24 @@ class BASE_EXPORT SimpleThread : public PlatformThread::Delegate { const std::string name_prefix_; std::string name_; const Options options_; - PlatformThreadHandle thread_; // PlatformThread handle, invalid after Join! + PlatformThreadHandle thread_; // PlatformThread handle, reset after Join. WaitableEvent event_; // Signaled if Start() was ever called. - PlatformThreadId tid_; // The backing thread's id. - bool joined_; // True if Join has been called. + PlatformThreadId tid_ = kInvalidThreadId; // The backing thread's id. + bool joined_ = false; // True if Join has been called. + + DISALLOW_COPY_AND_ASSIGN(SimpleThread); }; +// A SimpleThread which delegates Run() to its Delegate. Non-joinable +// DelegateSimpleThread are safe to delete after Run() was invoked, their +// Delegates are also safe to delete after that point from this class' point of +// view (although implementations must of course make sure that Run() will not +// use their Delegate's member state after its deletion). class BASE_EXPORT DelegateSimpleThread : public SimpleThread { public: class BASE_EXPORT Delegate { public: - Delegate() { } - virtual ~Delegate() { } + virtual ~Delegate() = default; virtual void Run() = 0; }; @@ -142,6 +144,8 @@ class BASE_EXPORT DelegateSimpleThread : public SimpleThread { private: Delegate* delegate_; + + DISALLOW_COPY_AND_ASSIGN(DelegateSimpleThread); }; // DelegateSimpleThreadPool allows you to start up a fixed number of threads, @@ -186,6 +190,8 @@ class BASE_EXPORT DelegateSimpleThreadPool std::queue<Delegate*> delegates_; base::Lock lock_; // Locks delegates_ WaitableEvent dry_; // Not signaled when there is no work to do. + + DISALLOW_COPY_AND_ASSIGN(DelegateSimpleThreadPool); }; } // namespace base |