1 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/threading/simple_thread.h"
6
7 #include "base/logging.h"
8 #include "base/strings/string_number_conversions.h"
9 #include "base/threading/platform_thread.h"
10 #include "base/threading/thread_restrictions.h"
11
12 namespace base {
13
SimpleThread(const std::string & name_prefix)14 SimpleThread::SimpleThread(const std::string& name_prefix)
15 : name_prefix_(name_prefix),
16 name_(name_prefix),
17 thread_(),
18 event_(WaitableEvent::ResetPolicy::MANUAL,
19 WaitableEvent::InitialState::NOT_SIGNALED),
20 tid_(0),
21 joined_(false) {}
22
SimpleThread(const std::string & name_prefix,const Options & options)23 SimpleThread::SimpleThread(const std::string& name_prefix,
24 const Options& options)
25 : name_prefix_(name_prefix),
26 name_(name_prefix),
27 options_(options),
28 thread_(),
29 event_(WaitableEvent::ResetPolicy::MANUAL,
30 WaitableEvent::InitialState::NOT_SIGNALED),
31 tid_(0),
32 joined_(false) {}
33
~SimpleThread()34 SimpleThread::~SimpleThread() {
35 DCHECK(HasBeenStarted()) << "SimpleThread was never started.";
36 DCHECK(HasBeenJoined()) << "SimpleThread destroyed without being Join()ed.";
37 }
38
Start()39 void SimpleThread::Start() {
40 DCHECK(!HasBeenStarted()) << "Tried to Start a thread multiple times.";
41 bool success;
42 if (options_.priority() == ThreadPriority::NORMAL) {
43 success = PlatformThread::Create(options_.stack_size(), this, &thread_);
44 } else {
45 success = PlatformThread::CreateWithPriority(options_.stack_size(), this,
46 &thread_, options_.priority());
47 }
48 DCHECK(success);
49 base::ThreadRestrictions::ScopedAllowWait allow_wait;
50 event_.Wait(); // Wait for the thread to complete initialization.
51 }
52
Join()53 void SimpleThread::Join() {
54 DCHECK(HasBeenStarted()) << "Tried to Join a never-started thread.";
55 DCHECK(!HasBeenJoined()) << "Tried to Join a thread multiple times.";
56 PlatformThread::Join(thread_);
57 joined_ = true;
58 }
59
HasBeenStarted()60 bool SimpleThread::HasBeenStarted() {
61 base::ThreadRestrictions::ScopedAllowWait allow_wait;
62 return event_.IsSignaled();
63 }
64
ThreadMain()65 void SimpleThread::ThreadMain() {
66 tid_ = PlatformThread::CurrentId();
67 // Construct our full name of the form "name_prefix_/TID".
68 name_.push_back('/');
69 name_.append(IntToString(tid_));
70 PlatformThread::SetName(name_);
71
72 // We've initialized our new thread, signal that we're done to Start().
73 event_.Signal();
74
75 Run();
76 }
77
DelegateSimpleThread(Delegate * delegate,const std::string & name_prefix)78 DelegateSimpleThread::DelegateSimpleThread(Delegate* delegate,
79 const std::string& name_prefix)
80 : SimpleThread(name_prefix),
81 delegate_(delegate) {
82 }
83
DelegateSimpleThread(Delegate * delegate,const std::string & name_prefix,const Options & options)84 DelegateSimpleThread::DelegateSimpleThread(Delegate* delegate,
85 const std::string& name_prefix,
86 const Options& options)
87 : SimpleThread(name_prefix, options),
88 delegate_(delegate) {
89 }
90
~DelegateSimpleThread()91 DelegateSimpleThread::~DelegateSimpleThread() {
92 }
93
Run()94 void DelegateSimpleThread::Run() {
95 DCHECK(delegate_) << "Tried to call Run without a delegate (called twice?)";
96 delegate_->Run();
97 delegate_ = NULL;
98 }
99
DelegateSimpleThreadPool(const std::string & name_prefix,int num_threads)100 DelegateSimpleThreadPool::DelegateSimpleThreadPool(
101 const std::string& name_prefix,
102 int num_threads)
103 : name_prefix_(name_prefix),
104 num_threads_(num_threads),
105 dry_(WaitableEvent::ResetPolicy::MANUAL,
106 WaitableEvent::InitialState::NOT_SIGNALED) {}
107
~DelegateSimpleThreadPool()108 DelegateSimpleThreadPool::~DelegateSimpleThreadPool() {
109 DCHECK(threads_.empty());
110 DCHECK(delegates_.empty());
111 DCHECK(!dry_.IsSignaled());
112 }
113
Start()114 void DelegateSimpleThreadPool::Start() {
115 DCHECK(threads_.empty()) << "Start() called with outstanding threads.";
116 for (int i = 0; i < num_threads_; ++i) {
117 DelegateSimpleThread* thread = new DelegateSimpleThread(this, name_prefix_);
118 thread->Start();
119 threads_.push_back(thread);
120 }
121 }
122
JoinAll()123 void DelegateSimpleThreadPool::JoinAll() {
124 DCHECK(!threads_.empty()) << "JoinAll() called with no outstanding threads.";
125
126 // Tell all our threads to quit their worker loop.
127 AddWork(NULL, num_threads_);
128
129 // Join and destroy all the worker threads.
130 for (int i = 0; i < num_threads_; ++i) {
131 threads_[i]->Join();
132 delete threads_[i];
133 }
134 threads_.clear();
135 DCHECK(delegates_.empty());
136 }
137
AddWork(Delegate * delegate,int repeat_count)138 void DelegateSimpleThreadPool::AddWork(Delegate* delegate, int repeat_count) {
139 AutoLock locked(lock_);
140 for (int i = 0; i < repeat_count; ++i)
141 delegates_.push(delegate);
142 // If we were empty, signal that we have work now.
143 if (!dry_.IsSignaled())
144 dry_.Signal();
145 }
146
Run()147 void DelegateSimpleThreadPool::Run() {
148 Delegate* work = NULL;
149
150 while (true) {
151 dry_.Wait();
152 {
153 AutoLock locked(lock_);
154 if (!dry_.IsSignaled())
155 continue;
156
157 DCHECK(!delegates_.empty());
158 work = delegates_.front();
159 delegates_.pop();
160
161 // Signal to any other threads that we're currently out of work.
162 if (delegates_.empty())
163 dry_.Reset();
164 }
165
166 // A NULL delegate pointer signals us to quit.
167 if (!work)
168 break;
169
170 work->Run();
171 }
172 }
173
174 } // namespace base
175