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