1 /*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 // #define LOG_NDEBUG 0
18 #define LOG_TAG "libutils.threads"
19
20 #include <assert.h>
21 #include <utils/AndroidThreads.h>
22 #include <utils/Thread.h>
23
24 #if !defined(_WIN32)
25 # include <sys/resource.h>
26 #else
27 # include <windows.h>
28 # include <stdint.h>
29 # include <process.h>
30 # define HAVE_CREATETHREAD // Cygwin, vs. HAVE__BEGINTHREADEX for MinGW
31 #endif
32
33 #if defined(__linux__)
34 #include <sys/prctl.h>
35 #endif
36
37 #include <utils/Log.h>
38
39 #if defined(__ANDROID__)
40 #include <processgroup/processgroup.h>
41 #include <processgroup/sched_policy.h>
42 #endif
43
44 #if defined(__ANDROID__)
45 # define __android_unused
46 #else
47 # define __android_unused __attribute__((__unused__))
48 #endif
49
50 /*
51 * ===========================================================================
52 * Thread wrappers
53 * ===========================================================================
54 */
55
56 using namespace android;
57
58 // ----------------------------------------------------------------------------
59 #if !defined(_WIN32)
60 // ----------------------------------------------------------------------------
61
62 /*
63 * Create and run a new thread.
64 *
65 * We create it "detached", so it cleans up after itself.
66 */
67
68 typedef void* (*android_pthread_entry)(void*);
69
70 #if defined(__ANDROID__)
71 struct thread_data_t {
72 thread_func_t entryFunction;
73 void* userData;
74 int priority;
75 char * threadName;
76
77 // we use this trampoline when we need to set the priority with
78 // nice/setpriority, and name with prctl.
trampolinethread_data_t79 static int trampoline(const thread_data_t* t) {
80 thread_func_t f = t->entryFunction;
81 void* u = t->userData;
82 int prio = t->priority;
83 char * name = t->threadName;
84 delete t;
85 setpriority(PRIO_PROCESS, 0, prio);
86
87 // A new thread will be in its parent's sched group by default,
88 // so we just need to handle the background case.
89 if (prio >= ANDROID_PRIORITY_BACKGROUND) {
90 SetTaskProfiles(0, {"SCHED_SP_BACKGROUND"}, true);
91 }
92
93 if (name) {
94 androidSetThreadName(name);
95 free(name);
96 }
97 return f(u);
98 }
99 };
100 #endif
101
androidSetThreadName(const char * name)102 void androidSetThreadName(const char* name) {
103 #if defined(__linux__)
104 // Mac OS doesn't have this, and we build libutil for the host too
105 int hasAt = 0;
106 int hasDot = 0;
107 const char *s = name;
108 while (*s) {
109 if (*s == '.') hasDot = 1;
110 else if (*s == '@') hasAt = 1;
111 s++;
112 }
113 int len = s - name;
114 if (len < 15 || hasAt || !hasDot) {
115 s = name;
116 } else {
117 s = name + len - 15;
118 }
119 prctl(PR_SET_NAME, (unsigned long) s, 0, 0, 0);
120 #endif
121 }
122
androidCreateRawThreadEtc(android_thread_func_t entryFunction,void * userData,const char * threadName __android_unused,int32_t threadPriority,size_t threadStackSize,android_thread_id_t * threadId)123 int androidCreateRawThreadEtc(android_thread_func_t entryFunction,
124 void *userData,
125 const char* threadName __android_unused,
126 int32_t threadPriority,
127 size_t threadStackSize,
128 android_thread_id_t *threadId)
129 {
130 pthread_attr_t attr;
131 pthread_attr_init(&attr);
132 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
133
134 #if defined(__ANDROID__) /* valgrind is rejecting RT-priority create reqs */
135 if (threadPriority != PRIORITY_DEFAULT || threadName != NULL) {
136 // Now that the pthread_t has a method to find the associated
137 // android_thread_id_t (pid) from pthread_t, it would be possible to avoid
138 // this trampoline in some cases as the parent could set the properties
139 // for the child. However, there would be a race condition because the
140 // child becomes ready immediately, and it doesn't work for the name.
141 // prctl(PR_SET_NAME) only works for self; prctl(PR_SET_THREAD_NAME) was
142 // proposed but not yet accepted.
143 thread_data_t* t = new thread_data_t;
144 t->priority = threadPriority;
145 t->threadName = threadName ? strdup(threadName) : NULL;
146 t->entryFunction = entryFunction;
147 t->userData = userData;
148 entryFunction = (android_thread_func_t)&thread_data_t::trampoline;
149 userData = t;
150 }
151 #endif
152
153 if (threadStackSize) {
154 pthread_attr_setstacksize(&attr, threadStackSize);
155 }
156
157 errno = 0;
158 pthread_t thread;
159 int result = pthread_create(&thread, &attr,
160 (android_pthread_entry)entryFunction, userData);
161 pthread_attr_destroy(&attr);
162 if (result != 0) {
163 ALOGE("androidCreateRawThreadEtc failed (entry=%p, res=%d, %s)\n"
164 "(android threadPriority=%d)",
165 entryFunction, result, strerror(errno), threadPriority);
166 return 0;
167 }
168
169 // Note that *threadID is directly available to the parent only, as it is
170 // assigned after the child starts. Use memory barrier / lock if the child
171 // or other threads also need access.
172 if (threadId != nullptr) {
173 *threadId = (android_thread_id_t)thread; // XXX: this is not portable
174 }
175 return 1;
176 }
177
178 #if defined(__ANDROID__)
android_thread_id_t_to_pthread(android_thread_id_t thread)179 static pthread_t android_thread_id_t_to_pthread(android_thread_id_t thread)
180 {
181 return (pthread_t) thread;
182 }
183 #endif
184
androidGetThreadId()185 android_thread_id_t androidGetThreadId()
186 {
187 return (android_thread_id_t)pthread_self();
188 }
189
190 // ----------------------------------------------------------------------------
191 #else // !defined(_WIN32)
192 // ----------------------------------------------------------------------------
193
194 /*
195 * Trampoline to make us __stdcall-compliant.
196 *
197 * We're expected to delete "vDetails" when we're done.
198 */
199 struct threadDetails {
200 int (*func)(void*);
201 void* arg;
202 };
threadIntermediary(void * vDetails)203 static __stdcall unsigned int threadIntermediary(void* vDetails)
204 {
205 struct threadDetails* pDetails = (struct threadDetails*) vDetails;
206 int result;
207
208 result = (*(pDetails->func))(pDetails->arg);
209
210 delete pDetails;
211
212 ALOG(LOG_VERBOSE, "thread", "thread exiting\n");
213 return (unsigned int) result;
214 }
215
216 /*
217 * Create and run a new thread.
218 */
doCreateThread(android_thread_func_t fn,void * arg,android_thread_id_t * id)219 static bool doCreateThread(android_thread_func_t fn, void* arg, android_thread_id_t *id)
220 {
221 HANDLE hThread;
222 struct threadDetails* pDetails = new threadDetails; // must be on heap
223 unsigned int thrdaddr;
224
225 pDetails->func = fn;
226 pDetails->arg = arg;
227
228 #if defined(HAVE__BEGINTHREADEX)
229 hThread = (HANDLE) _beginthreadex(NULL, 0, threadIntermediary, pDetails, 0,
230 &thrdaddr);
231 if (hThread == 0)
232 #elif defined(HAVE_CREATETHREAD)
233 hThread = CreateThread(NULL, 0,
234 (LPTHREAD_START_ROUTINE) threadIntermediary,
235 (void*) pDetails, 0, (DWORD*) &thrdaddr);
236 if (hThread == NULL)
237 #endif
238 {
239 ALOG(LOG_WARN, "thread", "WARNING: thread create failed\n");
240 return false;
241 }
242
243 #if defined(HAVE_CREATETHREAD)
244 /* close the management handle */
245 CloseHandle(hThread);
246 #endif
247
248 if (id != NULL) {
249 *id = (android_thread_id_t)thrdaddr;
250 }
251
252 return true;
253 }
254
androidCreateRawThreadEtc(android_thread_func_t fn,void * userData,const char *,int32_t,size_t,android_thread_id_t * threadId)255 int androidCreateRawThreadEtc(android_thread_func_t fn,
256 void *userData,
257 const char* /*threadName*/,
258 int32_t /*threadPriority*/,
259 size_t /*threadStackSize*/,
260 android_thread_id_t *threadId)
261 {
262 return doCreateThread( fn, userData, threadId);
263 }
264
androidGetThreadId()265 android_thread_id_t androidGetThreadId()
266 {
267 return (android_thread_id_t)GetCurrentThreadId();
268 }
269
270 // ----------------------------------------------------------------------------
271 #endif // !defined(_WIN32)
272
273 // ----------------------------------------------------------------------------
274
androidCreateThread(android_thread_func_t fn,void * arg)275 int androidCreateThread(android_thread_func_t fn, void* arg)
276 {
277 return createThreadEtc(fn, arg);
278 }
279
androidCreateThreadGetID(android_thread_func_t fn,void * arg,android_thread_id_t * id)280 int androidCreateThreadGetID(android_thread_func_t fn, void *arg, android_thread_id_t *id)
281 {
282 return createThreadEtc(fn, arg, "android:unnamed_thread",
283 PRIORITY_DEFAULT, 0, id);
284 }
285
286 static android_create_thread_fn gCreateThreadFn = androidCreateRawThreadEtc;
287
androidCreateThreadEtc(android_thread_func_t entryFunction,void * userData,const char * threadName,int32_t threadPriority,size_t threadStackSize,android_thread_id_t * threadId)288 int androidCreateThreadEtc(android_thread_func_t entryFunction,
289 void *userData,
290 const char* threadName,
291 int32_t threadPriority,
292 size_t threadStackSize,
293 android_thread_id_t *threadId)
294 {
295 return gCreateThreadFn(entryFunction, userData, threadName,
296 threadPriority, threadStackSize, threadId);
297 }
298
androidSetCreateThreadFunc(android_create_thread_fn func)299 void androidSetCreateThreadFunc(android_create_thread_fn func)
300 {
301 gCreateThreadFn = func;
302 }
303
304 #if defined(__ANDROID__)
androidSetThreadPriority(pid_t tid,int pri)305 int androidSetThreadPriority(pid_t tid, int pri)
306 {
307 int rc = 0;
308 int lasterr = 0;
309 int curr_pri = getpriority(PRIO_PROCESS, tid);
310
311 if (curr_pri == pri) {
312 return rc;
313 }
314
315 if (pri >= ANDROID_PRIORITY_BACKGROUND) {
316 rc = SetTaskProfiles(tid, {"SCHED_SP_BACKGROUND"}, true) ? 0 : -1;
317 } else if (curr_pri >= ANDROID_PRIORITY_BACKGROUND) {
318 SchedPolicy policy = SP_FOREGROUND;
319 // Change to the sched policy group of the process.
320 get_sched_policy(getpid(), &policy);
321 rc = SetTaskProfiles(tid, {get_sched_policy_profile_name(policy)}, true) ? 0 : -1;
322 }
323
324 if (rc) {
325 lasterr = errno;
326 }
327
328 if (setpriority(PRIO_PROCESS, tid, pri) < 0) {
329 rc = INVALID_OPERATION;
330 } else {
331 errno = lasterr;
332 }
333
334 return rc;
335 }
336
androidGetThreadPriority(pid_t tid)337 int androidGetThreadPriority(pid_t tid) {
338 return getpriority(PRIO_PROCESS, tid);
339 }
340
341 #endif
342
343 namespace android {
344
345 /*
346 * ===========================================================================
347 * Mutex class
348 * ===========================================================================
349 */
350
351 #if !defined(_WIN32)
352 // implemented as inlines in threads.h
353 #else
354
355 Mutex::Mutex()
356 {
357 HANDLE hMutex;
358
359 assert(sizeof(hMutex) == sizeof(mState));
360
361 hMutex = CreateMutex(NULL, FALSE, NULL);
362 mState = (void*) hMutex;
363 }
364
365 Mutex::Mutex(const char* /*name*/)
366 {
367 // XXX: name not used for now
368 HANDLE hMutex;
369
370 assert(sizeof(hMutex) == sizeof(mState));
371
372 hMutex = CreateMutex(NULL, FALSE, NULL);
373 mState = (void*) hMutex;
374 }
375
376 Mutex::Mutex(int /*type*/, const char* /*name*/)
377 {
378 // XXX: type and name not used for now
379 HANDLE hMutex;
380
381 assert(sizeof(hMutex) == sizeof(mState));
382
383 hMutex = CreateMutex(NULL, FALSE, NULL);
384 mState = (void*) hMutex;
385 }
386
387 Mutex::~Mutex()
388 {
389 CloseHandle((HANDLE) mState);
390 }
391
392 status_t Mutex::lock()
393 {
394 DWORD dwWaitResult;
395 dwWaitResult = WaitForSingleObject((HANDLE) mState, INFINITE);
396 return dwWaitResult != WAIT_OBJECT_0 ? -1 : OK;
397 }
398
399 void Mutex::unlock()
400 {
401 if (!ReleaseMutex((HANDLE) mState))
402 ALOG(LOG_WARN, "thread", "WARNING: bad result from unlocking mutex\n");
403 }
404
405 status_t Mutex::tryLock()
406 {
407 DWORD dwWaitResult;
408
409 dwWaitResult = WaitForSingleObject((HANDLE) mState, 0);
410 if (dwWaitResult != WAIT_OBJECT_0 && dwWaitResult != WAIT_TIMEOUT)
411 ALOG(LOG_WARN, "thread", "WARNING: bad result from try-locking mutex\n");
412 return (dwWaitResult == WAIT_OBJECT_0) ? 0 : -1;
413 }
414
415 #endif // !defined(_WIN32)
416
417
418 /*
419 * ===========================================================================
420 * Condition class
421 * ===========================================================================
422 */
423
424 #if !defined(_WIN32)
425 // implemented as inlines in threads.h
426 #else
427
428 /*
429 * Windows doesn't have a condition variable solution. It's possible
430 * to create one, but it's easy to get it wrong. For a discussion, and
431 * the origin of this implementation, see:
432 *
433 * http://www.cs.wustl.edu/~schmidt/win32-cv-1.html
434 *
435 * The implementation shown on the page does NOT follow POSIX semantics.
436 * As an optimization they require acquiring the external mutex before
437 * calling signal() and broadcast(), whereas POSIX only requires grabbing
438 * it before calling wait(). The implementation here has been un-optimized
439 * to have the correct behavior.
440 */
441 typedef struct WinCondition {
442 // Number of waiting threads.
443 int waitersCount;
444
445 // Serialize access to waitersCount.
446 CRITICAL_SECTION waitersCountLock;
447
448 // Semaphore used to queue up threads waiting for the condition to
449 // become signaled.
450 HANDLE sema;
451
452 // An auto-reset event used by the broadcast/signal thread to wait
453 // for all the waiting thread(s) to wake up and be released from
454 // the semaphore.
455 HANDLE waitersDone;
456
457 // This mutex wouldn't be necessary if we required that the caller
458 // lock the external mutex before calling signal() and broadcast().
459 // I'm trying to mimic pthread semantics though.
460 HANDLE internalMutex;
461
462 // Keeps track of whether we were broadcasting or signaling. This
463 // allows us to optimize the code if we're just signaling.
464 bool wasBroadcast;
465
466 status_t wait(WinCondition* condState, HANDLE hMutex, nsecs_t* abstime)
467 {
468 // Increment the wait count, avoiding race conditions.
469 EnterCriticalSection(&condState->waitersCountLock);
470 condState->waitersCount++;
471 //printf("+++ wait: incr waitersCount to %d (tid=%ld)\n",
472 // condState->waitersCount, getThreadId());
473 LeaveCriticalSection(&condState->waitersCountLock);
474
475 DWORD timeout = INFINITE;
476 if (abstime) {
477 nsecs_t reltime = *abstime - systemTime();
478 if (reltime < 0)
479 reltime = 0;
480 timeout = reltime/1000000;
481 }
482
483 // Atomically release the external mutex and wait on the semaphore.
484 DWORD res =
485 SignalObjectAndWait(hMutex, condState->sema, timeout, FALSE);
486
487 //printf("+++ wait: awake (tid=%ld)\n", getThreadId());
488
489 // Reacquire lock to avoid race conditions.
490 EnterCriticalSection(&condState->waitersCountLock);
491
492 // No longer waiting.
493 condState->waitersCount--;
494
495 // Check to see if we're the last waiter after a broadcast.
496 bool lastWaiter = (condState->wasBroadcast && condState->waitersCount == 0);
497
498 //printf("+++ wait: lastWaiter=%d (wasBc=%d wc=%d)\n",
499 // lastWaiter, condState->wasBroadcast, condState->waitersCount);
500
501 LeaveCriticalSection(&condState->waitersCountLock);
502
503 // If we're the last waiter thread during this particular broadcast
504 // then signal broadcast() that we're all awake. It'll drop the
505 // internal mutex.
506 if (lastWaiter) {
507 // Atomically signal the "waitersDone" event and wait until we
508 // can acquire the internal mutex. We want to do this in one step
509 // because it ensures that everybody is in the mutex FIFO before
510 // any thread has a chance to run. Without it, another thread
511 // could wake up, do work, and hop back in ahead of us.
512 SignalObjectAndWait(condState->waitersDone, condState->internalMutex,
513 INFINITE, FALSE);
514 } else {
515 // Grab the internal mutex.
516 WaitForSingleObject(condState->internalMutex, INFINITE);
517 }
518
519 // Release the internal and grab the external.
520 ReleaseMutex(condState->internalMutex);
521 WaitForSingleObject(hMutex, INFINITE);
522
523 return res == WAIT_OBJECT_0 ? OK : -1;
524 }
525 } WinCondition;
526
527 /*
528 * Constructor. Set up the WinCondition stuff.
529 */
530 Condition::Condition()
531 {
532 WinCondition* condState = new WinCondition;
533
534 condState->waitersCount = 0;
535 condState->wasBroadcast = false;
536 // semaphore: no security, initial value of 0
537 condState->sema = CreateSemaphore(NULL, 0, 0x7fffffff, NULL);
538 InitializeCriticalSection(&condState->waitersCountLock);
539 // auto-reset event, not signaled initially
540 condState->waitersDone = CreateEvent(NULL, FALSE, FALSE, NULL);
541 // used so we don't have to lock external mutex on signal/broadcast
542 condState->internalMutex = CreateMutex(NULL, FALSE, NULL);
543
544 mState = condState;
545 }
546
547 /*
548 * Destructor. Free Windows resources as well as our allocated storage.
549 */
550 Condition::~Condition()
551 {
552 WinCondition* condState = (WinCondition*) mState;
553 if (condState != NULL) {
554 CloseHandle(condState->sema);
555 CloseHandle(condState->waitersDone);
556 delete condState;
557 }
558 }
559
560
561 status_t Condition::wait(Mutex& mutex)
562 {
563 WinCondition* condState = (WinCondition*) mState;
564 HANDLE hMutex = (HANDLE) mutex.mState;
565
566 return ((WinCondition*)mState)->wait(condState, hMutex, NULL);
567 }
568
569 status_t Condition::waitRelative(Mutex& mutex, nsecs_t reltime)
570 {
571 WinCondition* condState = (WinCondition*) mState;
572 HANDLE hMutex = (HANDLE) mutex.mState;
573 nsecs_t absTime = systemTime()+reltime;
574
575 return ((WinCondition*)mState)->wait(condState, hMutex, &absTime);
576 }
577
578 /*
579 * Signal the condition variable, allowing one thread to continue.
580 */
581 void Condition::signal()
582 {
583 WinCondition* condState = (WinCondition*) mState;
584
585 // Lock the internal mutex. This ensures that we don't clash with
586 // broadcast().
587 WaitForSingleObject(condState->internalMutex, INFINITE);
588
589 EnterCriticalSection(&condState->waitersCountLock);
590 bool haveWaiters = (condState->waitersCount > 0);
591 LeaveCriticalSection(&condState->waitersCountLock);
592
593 // If no waiters, then this is a no-op. Otherwise, knock the semaphore
594 // down a notch.
595 if (haveWaiters)
596 ReleaseSemaphore(condState->sema, 1, 0);
597
598 // Release internal mutex.
599 ReleaseMutex(condState->internalMutex);
600 }
601
602 /*
603 * Signal the condition variable, allowing all threads to continue.
604 *
605 * First we have to wake up all threads waiting on the semaphore, then
606 * we wait until all of the threads have actually been woken before
607 * releasing the internal mutex. This ensures that all threads are woken.
608 */
609 void Condition::broadcast()
610 {
611 WinCondition* condState = (WinCondition*) mState;
612
613 // Lock the internal mutex. This keeps the guys we're waking up
614 // from getting too far.
615 WaitForSingleObject(condState->internalMutex, INFINITE);
616
617 EnterCriticalSection(&condState->waitersCountLock);
618 bool haveWaiters = false;
619
620 if (condState->waitersCount > 0) {
621 haveWaiters = true;
622 condState->wasBroadcast = true;
623 }
624
625 if (haveWaiters) {
626 // Wake up all the waiters.
627 ReleaseSemaphore(condState->sema, condState->waitersCount, 0);
628
629 LeaveCriticalSection(&condState->waitersCountLock);
630
631 // Wait for all awakened threads to acquire the counting semaphore.
632 // The last guy who was waiting sets this.
633 WaitForSingleObject(condState->waitersDone, INFINITE);
634
635 // Reset wasBroadcast. (No crit section needed because nobody
636 // else can wake up to poke at it.)
637 condState->wasBroadcast = 0;
638 } else {
639 // nothing to do
640 LeaveCriticalSection(&condState->waitersCountLock);
641 }
642
643 // Release internal mutex.
644 ReleaseMutex(condState->internalMutex);
645 }
646
647 #endif // !defined(_WIN32)
648
649 // ----------------------------------------------------------------------------
650
651 /*
652 * This is our thread object!
653 */
654
Thread(bool canCallJava)655 Thread::Thread(bool canCallJava)
656 : mCanCallJava(canCallJava),
657 mThread(thread_id_t(-1)),
658 mLock("Thread::mLock"),
659 mStatus(OK),
660 mExitPending(false),
661 mRunning(false)
662 #if defined(__ANDROID__)
663 ,
664 mTid(-1)
665 #endif
666 {
667 }
668
~Thread()669 Thread::~Thread()
670 {
671 }
672
readyToRun()673 status_t Thread::readyToRun()
674 {
675 return OK;
676 }
677
run(const char * name,int32_t priority,size_t stack)678 status_t Thread::run(const char* name, int32_t priority, size_t stack)
679 {
680 LOG_ALWAYS_FATAL_IF(name == nullptr, "thread name not provided to Thread::run");
681
682 Mutex::Autolock _l(mLock);
683
684 if (mRunning) {
685 // thread already started
686 return INVALID_OPERATION;
687 }
688
689 // reset status and exitPending to their default value, so we can
690 // try again after an error happened (either below, or in readyToRun())
691 mStatus = OK;
692 mExitPending = false;
693 mThread = thread_id_t(-1);
694
695 // hold a strong reference on ourself
696 mHoldSelf = this;
697
698 mRunning = true;
699
700 bool res;
701 if (mCanCallJava) {
702 res = createThreadEtc(_threadLoop,
703 this, name, priority, stack, &mThread);
704 } else {
705 res = androidCreateRawThreadEtc(_threadLoop,
706 this, name, priority, stack, &mThread);
707 }
708
709 if (res == false) {
710 mStatus = UNKNOWN_ERROR; // something happened!
711 mRunning = false;
712 mThread = thread_id_t(-1);
713 mHoldSelf.clear(); // "this" may have gone away after this.
714
715 return UNKNOWN_ERROR;
716 }
717
718 // Do not refer to mStatus here: The thread is already running (may, in fact
719 // already have exited with a valid mStatus result). The OK indication
720 // here merely indicates successfully starting the thread and does not
721 // imply successful termination/execution.
722 return OK;
723
724 // Exiting scope of mLock is a memory barrier and allows new thread to run
725 }
726
_threadLoop(void * user)727 int Thread::_threadLoop(void* user)
728 {
729 Thread* const self = static_cast<Thread*>(user);
730
731 sp<Thread> strong(self->mHoldSelf);
732 wp<Thread> weak(strong);
733 self->mHoldSelf.clear();
734
735 #if defined(__ANDROID__)
736 // this is very useful for debugging with gdb
737 self->mTid = gettid();
738 #endif
739
740 bool first = true;
741
742 do {
743 bool result;
744 if (first) {
745 first = false;
746 self->mStatus = self->readyToRun();
747 result = (self->mStatus == OK);
748
749 if (result && !self->exitPending()) {
750 // Binder threads (and maybe others) rely on threadLoop
751 // running at least once after a successful ::readyToRun()
752 // (unless, of course, the thread has already been asked to exit
753 // at that point).
754 // This is because threads are essentially used like this:
755 // (new ThreadSubclass())->run();
756 // The caller therefore does not retain a strong reference to
757 // the thread and the thread would simply disappear after the
758 // successful ::readyToRun() call instead of entering the
759 // threadLoop at least once.
760 result = self->threadLoop();
761 }
762 } else {
763 result = self->threadLoop();
764 }
765
766 // establish a scope for mLock
767 {
768 Mutex::Autolock _l(self->mLock);
769 if (result == false || self->mExitPending) {
770 self->mExitPending = true;
771 self->mRunning = false;
772 // clear thread ID so that requestExitAndWait() does not exit if
773 // called by a new thread using the same thread ID as this one.
774 self->mThread = thread_id_t(-1);
775 // note that interested observers blocked in requestExitAndWait are
776 // awoken by broadcast, but blocked on mLock until break exits scope
777 self->mThreadExitedCondition.broadcast();
778 break;
779 }
780 }
781
782 // Release our strong reference, to let a chance to the thread
783 // to die a peaceful death.
784 strong.clear();
785 // And immediately, re-acquire a strong reference for the next loop
786 strong = weak.promote();
787 } while(strong != nullptr);
788
789 return 0;
790 }
791
requestExit()792 void Thread::requestExit()
793 {
794 Mutex::Autolock _l(mLock);
795 mExitPending = true;
796 }
797
requestExitAndWait()798 status_t Thread::requestExitAndWait()
799 {
800 Mutex::Autolock _l(mLock);
801 if (mThread == getThreadId()) {
802 ALOGW(
803 "Thread (this=%p): don't call waitForExit() from this "
804 "Thread object's thread. It's a guaranteed deadlock!",
805 this);
806
807 return WOULD_BLOCK;
808 }
809
810 mExitPending = true;
811
812 while (mRunning == true) {
813 mThreadExitedCondition.wait(mLock);
814 }
815 // This next line is probably not needed any more, but is being left for
816 // historical reference. Note that each interested party will clear flag.
817 mExitPending = false;
818
819 return mStatus;
820 }
821
join()822 status_t Thread::join()
823 {
824 Mutex::Autolock _l(mLock);
825 if (mThread == getThreadId()) {
826 ALOGW(
827 "Thread (this=%p): don't call join() from this "
828 "Thread object's thread. It's a guaranteed deadlock!",
829 this);
830
831 return WOULD_BLOCK;
832 }
833
834 while (mRunning == true) {
835 mThreadExitedCondition.wait(mLock);
836 }
837
838 return mStatus;
839 }
840
isRunning() const841 bool Thread::isRunning() const {
842 Mutex::Autolock _l(mLock);
843 return mRunning;
844 }
845
846 #if defined(__ANDROID__)
getTid() const847 pid_t Thread::getTid() const
848 {
849 // mTid is not defined until the child initializes it, and the caller may need it earlier
850 Mutex::Autolock _l(mLock);
851 pid_t tid;
852 if (mRunning) {
853 pthread_t pthread = android_thread_id_t_to_pthread(mThread);
854 tid = pthread_gettid_np(pthread);
855 } else {
856 ALOGW("Thread (this=%p): getTid() is undefined before run()", this);
857 tid = -1;
858 }
859 return tid;
860 }
861 #endif
862
exitPending() const863 bool Thread::exitPending() const
864 {
865 Mutex::Autolock _l(mLock);
866 return mExitPending;
867 }
868
869
870
871 }; // namespace android
872