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