• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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