| /* |
| * Copyright (C) 2007 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| // #define LOG_NDEBUG 0 |
| #define LOG_TAG "libutils.threads" |
| |
| #include <assert.h> |
| #include <errno.h> |
| #include <memory.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <unistd.h> |
| |
| #if !defined(_WIN32) |
| # include <pthread.h> |
| # include <sched.h> |
| # include <sys/resource.h> |
| #else |
| # include <windows.h> |
| # include <stdint.h> |
| # include <process.h> |
| # define HAVE_CREATETHREAD // Cygwin, vs. HAVE__BEGINTHREADEX for MinGW |
| #endif |
| |
| #if defined(__linux__) |
| #include <sys/prctl.h> |
| #endif |
| |
| #include <utils/threads.h> |
| #include <utils/Log.h> |
| |
| #include <cutils/sched_policy.h> |
| |
| #if defined(__ANDROID__) |
| # define __android_unused |
| #else |
| # define __android_unused __attribute__((__unused__)) |
| #endif |
| |
| /* |
| * =========================================================================== |
| * Thread wrappers |
| * =========================================================================== |
| */ |
| |
| using namespace android; |
| |
| // ---------------------------------------------------------------------------- |
| #if !defined(_WIN32) |
| // ---------------------------------------------------------------------------- |
| |
| /* |
| * Create and run a new thread. |
| * |
| * We create it "detached", so it cleans up after itself. |
| */ |
| |
| typedef void* (*android_pthread_entry)(void*); |
| |
| struct thread_data_t { |
| thread_func_t entryFunction; |
| void* userData; |
| int priority; |
| char * threadName; |
| |
| // we use this trampoline when we need to set the priority with |
| // nice/setpriority, and name with prctl. |
| static int trampoline(const thread_data_t* t) { |
| thread_func_t f = t->entryFunction; |
| void* u = t->userData; |
| int prio = t->priority; |
| char * name = t->threadName; |
| delete t; |
| setpriority(PRIO_PROCESS, 0, prio); |
| if (prio >= ANDROID_PRIORITY_BACKGROUND) { |
| set_sched_policy(0, SP_BACKGROUND); |
| } else { |
| set_sched_policy(0, SP_FOREGROUND); |
| } |
| |
| if (name) { |
| androidSetThreadName(name); |
| free(name); |
| } |
| return f(u); |
| } |
| }; |
| |
| void androidSetThreadName(const char* name) { |
| #if defined(__linux__) |
| // Mac OS doesn't have this, and we build libutil for the host too |
| int hasAt = 0; |
| int hasDot = 0; |
| const char *s = name; |
| while (*s) { |
| if (*s == '.') hasDot = 1; |
| else if (*s == '@') hasAt = 1; |
| s++; |
| } |
| int len = s - name; |
| if (len < 15 || hasAt || !hasDot) { |
| s = name; |
| } else { |
| s = name + len - 15; |
| } |
| prctl(PR_SET_NAME, (unsigned long) s, 0, 0, 0); |
| #endif |
| } |
| |
| int androidCreateRawThreadEtc(android_thread_func_t entryFunction, |
| void *userData, |
| const char* threadName __android_unused, |
| int32_t threadPriority, |
| size_t threadStackSize, |
| android_thread_id_t *threadId) |
| { |
| pthread_attr_t attr; |
| pthread_attr_init(&attr); |
| pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); |
| |
| #if defined(__ANDROID__) /* valgrind is rejecting RT-priority create reqs */ |
| if (threadPriority != PRIORITY_DEFAULT || threadName != NULL) { |
| // Now that the pthread_t has a method to find the associated |
| // android_thread_id_t (pid) from pthread_t, it would be possible to avoid |
| // this trampoline in some cases as the parent could set the properties |
| // for the child. However, there would be a race condition because the |
| // child becomes ready immediately, and it doesn't work for the name. |
| // prctl(PR_SET_NAME) only works for self; prctl(PR_SET_THREAD_NAME) was |
| // proposed but not yet accepted. |
| thread_data_t* t = new thread_data_t; |
| t->priority = threadPriority; |
| t->threadName = threadName ? strdup(threadName) : NULL; |
| t->entryFunction = entryFunction; |
| t->userData = userData; |
| entryFunction = (android_thread_func_t)&thread_data_t::trampoline; |
| userData = t; |
| } |
| #endif |
| |
| if (threadStackSize) { |
| pthread_attr_setstacksize(&attr, threadStackSize); |
| } |
| |
| errno = 0; |
| pthread_t thread; |
| int result = pthread_create(&thread, &attr, |
| (android_pthread_entry)entryFunction, userData); |
| pthread_attr_destroy(&attr); |
| if (result != 0) { |
| ALOGE("androidCreateRawThreadEtc failed (entry=%p, res=%d, %s)\n" |
| "(android threadPriority=%d)", |
| entryFunction, result, strerror(errno), threadPriority); |
| return 0; |
| } |
| |
| // Note that *threadID is directly available to the parent only, as it is |
| // assigned after the child starts. Use memory barrier / lock if the child |
| // or other threads also need access. |
| if (threadId != NULL) { |
| *threadId = (android_thread_id_t)thread; // XXX: this is not portable |
| } |
| return 1; |
| } |
| |
| #if defined(__ANDROID__) |
| static pthread_t android_thread_id_t_to_pthread(android_thread_id_t thread) |
| { |
| return (pthread_t) thread; |
| } |
| #endif |
| |
| android_thread_id_t androidGetThreadId() |
| { |
| return (android_thread_id_t)pthread_self(); |
| } |
| |
| // ---------------------------------------------------------------------------- |
| #else // !defined(_WIN32) |
| // ---------------------------------------------------------------------------- |
| |
| /* |
| * Trampoline to make us __stdcall-compliant. |
| * |
| * We're expected to delete "vDetails" when we're done. |
| */ |
| struct threadDetails { |
| int (*func)(void*); |
| void* arg; |
| }; |
| static __stdcall unsigned int threadIntermediary(void* vDetails) |
| { |
| struct threadDetails* pDetails = (struct threadDetails*) vDetails; |
| int result; |
| |
| result = (*(pDetails->func))(pDetails->arg); |
| |
| delete pDetails; |
| |
| ALOG(LOG_VERBOSE, "thread", "thread exiting\n"); |
| return (unsigned int) result; |
| } |
| |
| /* |
| * Create and run a new thread. |
| */ |
| static bool doCreateThread(android_thread_func_t fn, void* arg, android_thread_id_t *id) |
| { |
| HANDLE hThread; |
| struct threadDetails* pDetails = new threadDetails; // must be on heap |
| unsigned int thrdaddr; |
| |
| pDetails->func = fn; |
| pDetails->arg = arg; |
| |
| #if defined(HAVE__BEGINTHREADEX) |
| hThread = (HANDLE) _beginthreadex(NULL, 0, threadIntermediary, pDetails, 0, |
| &thrdaddr); |
| if (hThread == 0) |
| #elif defined(HAVE_CREATETHREAD) |
| hThread = CreateThread(NULL, 0, |
| (LPTHREAD_START_ROUTINE) threadIntermediary, |
| (void*) pDetails, 0, (DWORD*) &thrdaddr); |
| if (hThread == NULL) |
| #endif |
| { |
| ALOG(LOG_WARN, "thread", "WARNING: thread create failed\n"); |
| return false; |
| } |
| |
| #if defined(HAVE_CREATETHREAD) |
| /* close the management handle */ |
| CloseHandle(hThread); |
| #endif |
| |
| if (id != NULL) { |
| *id = (android_thread_id_t)thrdaddr; |
| } |
| |
| return true; |
| } |
| |
| int androidCreateRawThreadEtc(android_thread_func_t fn, |
| void *userData, |
| const char* /*threadName*/, |
| int32_t /*threadPriority*/, |
| size_t /*threadStackSize*/, |
| android_thread_id_t *threadId) |
| { |
| return doCreateThread( fn, userData, threadId); |
| } |
| |
| android_thread_id_t androidGetThreadId() |
| { |
| return (android_thread_id_t)GetCurrentThreadId(); |
| } |
| |
| // ---------------------------------------------------------------------------- |
| #endif // !defined(_WIN32) |
| |
| // ---------------------------------------------------------------------------- |
| |
| int androidCreateThread(android_thread_func_t fn, void* arg) |
| { |
| return createThreadEtc(fn, arg); |
| } |
| |
| int androidCreateThreadGetID(android_thread_func_t fn, void *arg, android_thread_id_t *id) |
| { |
| return createThreadEtc(fn, arg, "android:unnamed_thread", |
| PRIORITY_DEFAULT, 0, id); |
| } |
| |
| static android_create_thread_fn gCreateThreadFn = androidCreateRawThreadEtc; |
| |
| int androidCreateThreadEtc(android_thread_func_t entryFunction, |
| void *userData, |
| const char* threadName, |
| int32_t threadPriority, |
| size_t threadStackSize, |
| android_thread_id_t *threadId) |
| { |
| return gCreateThreadFn(entryFunction, userData, threadName, |
| threadPriority, threadStackSize, threadId); |
| } |
| |
| void androidSetCreateThreadFunc(android_create_thread_fn func) |
| { |
| gCreateThreadFn = func; |
| } |
| |
| #if defined(__ANDROID__) |
| int androidSetThreadPriority(pid_t tid, int pri) |
| { |
| int rc = 0; |
| int lasterr = 0; |
| |
| if (pri >= ANDROID_PRIORITY_BACKGROUND) { |
| rc = set_sched_policy(tid, SP_BACKGROUND); |
| } else if (getpriority(PRIO_PROCESS, tid) >= ANDROID_PRIORITY_BACKGROUND) { |
| rc = set_sched_policy(tid, SP_FOREGROUND); |
| } |
| |
| if (rc) { |
| lasterr = errno; |
| } |
| |
| if (setpriority(PRIO_PROCESS, tid, pri) < 0) { |
| rc = INVALID_OPERATION; |
| } else { |
| errno = lasterr; |
| } |
| |
| return rc; |
| } |
| |
| int androidGetThreadPriority(pid_t tid) { |
| return getpriority(PRIO_PROCESS, tid); |
| } |
| |
| #endif |
| |
| namespace android { |
| |
| /* |
| * =========================================================================== |
| * Mutex class |
| * =========================================================================== |
| */ |
| |
| #if !defined(_WIN32) |
| // implemented as inlines in threads.h |
| #else |
| |
| Mutex::Mutex() |
| { |
| HANDLE hMutex; |
| |
| assert(sizeof(hMutex) == sizeof(mState)); |
| |
| hMutex = CreateMutex(NULL, FALSE, NULL); |
| mState = (void*) hMutex; |
| } |
| |
| Mutex::Mutex(const char* name) |
| { |
| // XXX: name not used for now |
| HANDLE hMutex; |
| |
| assert(sizeof(hMutex) == sizeof(mState)); |
| |
| hMutex = CreateMutex(NULL, FALSE, NULL); |
| mState = (void*) hMutex; |
| } |
| |
| Mutex::Mutex(int type, const char* name) |
| { |
| // XXX: type and name not used for now |
| HANDLE hMutex; |
| |
| assert(sizeof(hMutex) == sizeof(mState)); |
| |
| hMutex = CreateMutex(NULL, FALSE, NULL); |
| mState = (void*) hMutex; |
| } |
| |
| Mutex::~Mutex() |
| { |
| CloseHandle((HANDLE) mState); |
| } |
| |
| status_t Mutex::lock() |
| { |
| DWORD dwWaitResult; |
| dwWaitResult = WaitForSingleObject((HANDLE) mState, INFINITE); |
| return dwWaitResult != WAIT_OBJECT_0 ? -1 : NO_ERROR; |
| } |
| |
| void Mutex::unlock() |
| { |
| if (!ReleaseMutex((HANDLE) mState)) |
| ALOG(LOG_WARN, "thread", "WARNING: bad result from unlocking mutex\n"); |
| } |
| |
| status_t Mutex::tryLock() |
| { |
| DWORD dwWaitResult; |
| |
| dwWaitResult = WaitForSingleObject((HANDLE) mState, 0); |
| if (dwWaitResult != WAIT_OBJECT_0 && dwWaitResult != WAIT_TIMEOUT) |
| ALOG(LOG_WARN, "thread", "WARNING: bad result from try-locking mutex\n"); |
| return (dwWaitResult == WAIT_OBJECT_0) ? 0 : -1; |
| } |
| |
| #endif // !defined(_WIN32) |
| |
| |
| /* |
| * =========================================================================== |
| * Condition class |
| * =========================================================================== |
| */ |
| |
| #if !defined(_WIN32) |
| // implemented as inlines in threads.h |
| #else |
| |
| /* |
| * Windows doesn't have a condition variable solution. It's possible |
| * to create one, but it's easy to get it wrong. For a discussion, and |
| * the origin of this implementation, see: |
| * |
| * http://www.cs.wustl.edu/~schmidt/win32-cv-1.html |
| * |
| * The implementation shown on the page does NOT follow POSIX semantics. |
| * As an optimization they require acquiring the external mutex before |
| * calling signal() and broadcast(), whereas POSIX only requires grabbing |
| * it before calling wait(). The implementation here has been un-optimized |
| * to have the correct behavior. |
| */ |
| typedef struct WinCondition { |
| // Number of waiting threads. |
| int waitersCount; |
| |
| // Serialize access to waitersCount. |
| CRITICAL_SECTION waitersCountLock; |
| |
| // Semaphore used to queue up threads waiting for the condition to |
| // become signaled. |
| HANDLE sema; |
| |
| // An auto-reset event used by the broadcast/signal thread to wait |
| // for all the waiting thread(s) to wake up and be released from |
| // the semaphore. |
| HANDLE waitersDone; |
| |
| // This mutex wouldn't be necessary if we required that the caller |
| // lock the external mutex before calling signal() and broadcast(). |
| // I'm trying to mimic pthread semantics though. |
| HANDLE internalMutex; |
| |
| // Keeps track of whether we were broadcasting or signaling. This |
| // allows us to optimize the code if we're just signaling. |
| bool wasBroadcast; |
| |
| status_t wait(WinCondition* condState, HANDLE hMutex, nsecs_t* abstime) |
| { |
| // Increment the wait count, avoiding race conditions. |
| EnterCriticalSection(&condState->waitersCountLock); |
| condState->waitersCount++; |
| //printf("+++ wait: incr waitersCount to %d (tid=%ld)\n", |
| // condState->waitersCount, getThreadId()); |
| LeaveCriticalSection(&condState->waitersCountLock); |
| |
| DWORD timeout = INFINITE; |
| if (abstime) { |
| nsecs_t reltime = *abstime - systemTime(); |
| if (reltime < 0) |
| reltime = 0; |
| timeout = reltime/1000000; |
| } |
| |
| // Atomically release the external mutex and wait on the semaphore. |
| DWORD res = |
| SignalObjectAndWait(hMutex, condState->sema, timeout, FALSE); |
| |
| //printf("+++ wait: awake (tid=%ld)\n", getThreadId()); |
| |
| // Reacquire lock to avoid race conditions. |
| EnterCriticalSection(&condState->waitersCountLock); |
| |
| // No longer waiting. |
| condState->waitersCount--; |
| |
| // Check to see if we're the last waiter after a broadcast. |
| bool lastWaiter = (condState->wasBroadcast && condState->waitersCount == 0); |
| |
| //printf("+++ wait: lastWaiter=%d (wasBc=%d wc=%d)\n", |
| // lastWaiter, condState->wasBroadcast, condState->waitersCount); |
| |
| LeaveCriticalSection(&condState->waitersCountLock); |
| |
| // If we're the last waiter thread during this particular broadcast |
| // then signal broadcast() that we're all awake. It'll drop the |
| // internal mutex. |
| if (lastWaiter) { |
| // Atomically signal the "waitersDone" event and wait until we |
| // can acquire the internal mutex. We want to do this in one step |
| // because it ensures that everybody is in the mutex FIFO before |
| // any thread has a chance to run. Without it, another thread |
| // could wake up, do work, and hop back in ahead of us. |
| SignalObjectAndWait(condState->waitersDone, condState->internalMutex, |
| INFINITE, FALSE); |
| } else { |
| // Grab the internal mutex. |
| WaitForSingleObject(condState->internalMutex, INFINITE); |
| } |
| |
| // Release the internal and grab the external. |
| ReleaseMutex(condState->internalMutex); |
| WaitForSingleObject(hMutex, INFINITE); |
| |
| return res == WAIT_OBJECT_0 ? NO_ERROR : -1; |
| } |
| } WinCondition; |
| |
| /* |
| * Constructor. Set up the WinCondition stuff. |
| */ |
| Condition::Condition() |
| { |
| WinCondition* condState = new WinCondition; |
| |
| condState->waitersCount = 0; |
| condState->wasBroadcast = false; |
| // semaphore: no security, initial value of 0 |
| condState->sema = CreateSemaphore(NULL, 0, 0x7fffffff, NULL); |
| InitializeCriticalSection(&condState->waitersCountLock); |
| // auto-reset event, not signaled initially |
| condState->waitersDone = CreateEvent(NULL, FALSE, FALSE, NULL); |
| // used so we don't have to lock external mutex on signal/broadcast |
| condState->internalMutex = CreateMutex(NULL, FALSE, NULL); |
| |
| mState = condState; |
| } |
| |
| /* |
| * Destructor. Free Windows resources as well as our allocated storage. |
| */ |
| Condition::~Condition() |
| { |
| WinCondition* condState = (WinCondition*) mState; |
| if (condState != NULL) { |
| CloseHandle(condState->sema); |
| CloseHandle(condState->waitersDone); |
| delete condState; |
| } |
| } |
| |
| |
| status_t Condition::wait(Mutex& mutex) |
| { |
| WinCondition* condState = (WinCondition*) mState; |
| HANDLE hMutex = (HANDLE) mutex.mState; |
| |
| return ((WinCondition*)mState)->wait(condState, hMutex, NULL); |
| } |
| |
| status_t Condition::waitRelative(Mutex& mutex, nsecs_t reltime) |
| { |
| WinCondition* condState = (WinCondition*) mState; |
| HANDLE hMutex = (HANDLE) mutex.mState; |
| nsecs_t absTime = systemTime()+reltime; |
| |
| return ((WinCondition*)mState)->wait(condState, hMutex, &absTime); |
| } |
| |
| /* |
| * Signal the condition variable, allowing one thread to continue. |
| */ |
| void Condition::signal() |
| { |
| WinCondition* condState = (WinCondition*) mState; |
| |
| // Lock the internal mutex. This ensures that we don't clash with |
| // broadcast(). |
| WaitForSingleObject(condState->internalMutex, INFINITE); |
| |
| EnterCriticalSection(&condState->waitersCountLock); |
| bool haveWaiters = (condState->waitersCount > 0); |
| LeaveCriticalSection(&condState->waitersCountLock); |
| |
| // If no waiters, then this is a no-op. Otherwise, knock the semaphore |
| // down a notch. |
| if (haveWaiters) |
| ReleaseSemaphore(condState->sema, 1, 0); |
| |
| // Release internal mutex. |
| ReleaseMutex(condState->internalMutex); |
| } |
| |
| /* |
| * Signal the condition variable, allowing all threads to continue. |
| * |
| * First we have to wake up all threads waiting on the semaphore, then |
| * we wait until all of the threads have actually been woken before |
| * releasing the internal mutex. This ensures that all threads are woken. |
| */ |
| void Condition::broadcast() |
| { |
| WinCondition* condState = (WinCondition*) mState; |
| |
| // Lock the internal mutex. This keeps the guys we're waking up |
| // from getting too far. |
| WaitForSingleObject(condState->internalMutex, INFINITE); |
| |
| EnterCriticalSection(&condState->waitersCountLock); |
| bool haveWaiters = false; |
| |
| if (condState->waitersCount > 0) { |
| haveWaiters = true; |
| condState->wasBroadcast = true; |
| } |
| |
| if (haveWaiters) { |
| // Wake up all the waiters. |
| ReleaseSemaphore(condState->sema, condState->waitersCount, 0); |
| |
| LeaveCriticalSection(&condState->waitersCountLock); |
| |
| // Wait for all awakened threads to acquire the counting semaphore. |
| // The last guy who was waiting sets this. |
| WaitForSingleObject(condState->waitersDone, INFINITE); |
| |
| // Reset wasBroadcast. (No crit section needed because nobody |
| // else can wake up to poke at it.) |
| condState->wasBroadcast = 0; |
| } else { |
| // nothing to do |
| LeaveCriticalSection(&condState->waitersCountLock); |
| } |
| |
| // Release internal mutex. |
| ReleaseMutex(condState->internalMutex); |
| } |
| |
| #endif // !defined(_WIN32) |
| |
| // ---------------------------------------------------------------------------- |
| |
| /* |
| * This is our thread object! |
| */ |
| |
| Thread::Thread(bool canCallJava) |
| : mCanCallJava(canCallJava), |
| mThread(thread_id_t(-1)), |
| mLock("Thread::mLock"), |
| mStatus(NO_ERROR), |
| mExitPending(false), mRunning(false) |
| #if defined(__ANDROID__) |
| , mTid(-1) |
| #endif |
| { |
| } |
| |
| Thread::~Thread() |
| { |
| } |
| |
| status_t Thread::readyToRun() |
| { |
| return NO_ERROR; |
| } |
| |
| status_t Thread::run(const char* name, int32_t priority, size_t stack) |
| { |
| Mutex::Autolock _l(mLock); |
| |
| if (mRunning) { |
| // thread already started |
| return INVALID_OPERATION; |
| } |
| |
| // reset status and exitPending to their default value, so we can |
| // try again after an error happened (either below, or in readyToRun()) |
| mStatus = NO_ERROR; |
| mExitPending = false; |
| mThread = thread_id_t(-1); |
| |
| // hold a strong reference on ourself |
| mHoldSelf = this; |
| |
| mRunning = true; |
| |
| bool res; |
| if (mCanCallJava) { |
| res = createThreadEtc(_threadLoop, |
| this, name, priority, stack, &mThread); |
| } else { |
| res = androidCreateRawThreadEtc(_threadLoop, |
| this, name, priority, stack, &mThread); |
| } |
| |
| if (res == false) { |
| mStatus = UNKNOWN_ERROR; // something happened! |
| mRunning = false; |
| mThread = thread_id_t(-1); |
| mHoldSelf.clear(); // "this" may have gone away after this. |
| |
| return UNKNOWN_ERROR; |
| } |
| |
| // Do not refer to mStatus here: The thread is already running (may, in fact |
| // already have exited with a valid mStatus result). The NO_ERROR indication |
| // here merely indicates successfully starting the thread and does not |
| // imply successful termination/execution. |
| return NO_ERROR; |
| |
| // Exiting scope of mLock is a memory barrier and allows new thread to run |
| } |
| |
| int Thread::_threadLoop(void* user) |
| { |
| Thread* const self = static_cast<Thread*>(user); |
| |
| sp<Thread> strong(self->mHoldSelf); |
| wp<Thread> weak(strong); |
| self->mHoldSelf.clear(); |
| |
| #if defined(__ANDROID__) |
| // this is very useful for debugging with gdb |
| self->mTid = gettid(); |
| #endif |
| |
| bool first = true; |
| |
| do { |
| bool result; |
| if (first) { |
| first = false; |
| self->mStatus = self->readyToRun(); |
| result = (self->mStatus == NO_ERROR); |
| |
| if (result && !self->exitPending()) { |
| // Binder threads (and maybe others) rely on threadLoop |
| // running at least once after a successful ::readyToRun() |
| // (unless, of course, the thread has already been asked to exit |
| // at that point). |
| // This is because threads are essentially used like this: |
| // (new ThreadSubclass())->run(); |
| // The caller therefore does not retain a strong reference to |
| // the thread and the thread would simply disappear after the |
| // successful ::readyToRun() call instead of entering the |
| // threadLoop at least once. |
| result = self->threadLoop(); |
| } |
| } else { |
| result = self->threadLoop(); |
| } |
| |
| // establish a scope for mLock |
| { |
| Mutex::Autolock _l(self->mLock); |
| if (result == false || self->mExitPending) { |
| self->mExitPending = true; |
| self->mRunning = false; |
| // clear thread ID so that requestExitAndWait() does not exit if |
| // called by a new thread using the same thread ID as this one. |
| self->mThread = thread_id_t(-1); |
| // note that interested observers blocked in requestExitAndWait are |
| // awoken by broadcast, but blocked on mLock until break exits scope |
| self->mThreadExitedCondition.broadcast(); |
| break; |
| } |
| } |
| |
| // Release our strong reference, to let a chance to the thread |
| // to die a peaceful death. |
| strong.clear(); |
| // And immediately, re-acquire a strong reference for the next loop |
| strong = weak.promote(); |
| } while(strong != 0); |
| |
| return 0; |
| } |
| |
| void Thread::requestExit() |
| { |
| Mutex::Autolock _l(mLock); |
| mExitPending = true; |
| } |
| |
| status_t Thread::requestExitAndWait() |
| { |
| Mutex::Autolock _l(mLock); |
| if (mThread == getThreadId()) { |
| ALOGW( |
| "Thread (this=%p): don't call waitForExit() from this " |
| "Thread object's thread. It's a guaranteed deadlock!", |
| this); |
| |
| return WOULD_BLOCK; |
| } |
| |
| mExitPending = true; |
| |
| while (mRunning == true) { |
| mThreadExitedCondition.wait(mLock); |
| } |
| // This next line is probably not needed any more, but is being left for |
| // historical reference. Note that each interested party will clear flag. |
| mExitPending = false; |
| |
| return mStatus; |
| } |
| |
| status_t Thread::join() |
| { |
| Mutex::Autolock _l(mLock); |
| if (mThread == getThreadId()) { |
| ALOGW( |
| "Thread (this=%p): don't call join() from this " |
| "Thread object's thread. It's a guaranteed deadlock!", |
| this); |
| |
| return WOULD_BLOCK; |
| } |
| |
| while (mRunning == true) { |
| mThreadExitedCondition.wait(mLock); |
| } |
| |
| return mStatus; |
| } |
| |
| bool Thread::isRunning() const { |
| Mutex::Autolock _l(mLock); |
| return mRunning; |
| } |
| |
| #if defined(__ANDROID__) |
| pid_t Thread::getTid() const |
| { |
| // mTid is not defined until the child initializes it, and the caller may need it earlier |
| Mutex::Autolock _l(mLock); |
| pid_t tid; |
| if (mRunning) { |
| pthread_t pthread = android_thread_id_t_to_pthread(mThread); |
| tid = pthread_gettid_np(pthread); |
| } else { |
| ALOGW("Thread (this=%p): getTid() is undefined before run()", this); |
| tid = -1; |
| } |
| return tid; |
| } |
| #endif |
| |
| bool Thread::exitPending() const |
| { |
| Mutex::Autolock _l(mLock); |
| return mExitPending; |
| } |
| |
| |
| |
| }; // namespace android |