X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/547b93ab0418dac65dec147df08922d76ce351f9..2d956b58023a4955313a1c1531bc70a0deb0b831:/src/unix/threadpsx.cpp diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp index 7054897738..72be919335 100644 --- a/src/unix/threadpsx.cpp +++ b/src/unix/threadpsx.cpp @@ -2,13 +2,14 @@ // Name: threadpsx.cpp // Purpose: wxThread (Posix) Implementation // Author: Original from Wolfram Gloger/Guilhem Lavaux -// Modified by: +// Modified by: K. S. Sreeram (2002): POSIXified wxCondition, added wxSemaphore // Created: 04/22/98 // RCS-ID: $Id$ // Copyright: (c) Wolfram Gloger (1996, 1997) // Guilhem Lavaux (1998) -// Vadim Zeitlin (1999) +// Vadim Zeitlin (1999-2002) // Robert Roebling (1999) +// K. S. Sreeram (2002) // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// @@ -34,7 +35,7 @@ #include "wx/log.h" #include "wx/intl.h" #include "wx/dynarray.h" -#include "wx/listimpl.cpp" +#include "wx/timer.h" #include #include @@ -80,35 +81,6 @@ static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1; static void ScheduleThreadForDeletion(); static void DeleteThread(wxThread *This); -// ---------------------------------------------------------------------------- -// private classes -// ---------------------------------------------------------------------------- - -// same as wxMutexLocker but for "native" mutex -class MutexLock -{ -public: - MutexLock(pthread_mutex_t& mutex) - { - m_mutex = &mutex; - if ( pthread_mutex_lock(m_mutex) != 0 ) - { - wxLogDebug(_T("pthread_mutex_lock() failed")); - } - } - - ~MutexLock() - { - if ( pthread_mutex_unlock(m_mutex) != 0 ) - { - wxLogDebug(_T("pthread_mutex_unlock() failed")); - } - } - -private: - pthread_mutex_t *m_mutex; -}; - // ---------------------------------------------------------------------------- // types // ---------------------------------------------------------------------------- @@ -135,7 +107,7 @@ static pthread_key_t gs_keySelf; static size_t gs_nThreadsBeingDeleted = 0; // a mutex to protect gs_nThreadsBeingDeleted -static pthread_mutex_t gs_mutexDeleteThread; +static wxMutex *gs_mutexDeleteThread = (wxMutex *)NULL; // and a condition variable which will be signaled when all // gs_nThreadsBeingDeleted will have been deleted @@ -147,23 +119,31 @@ static wxCondition *gs_condAllDeleted = (wxCondition *)NULL; #endif // wxUSE_GUI // ============================================================================ -// implementation +// wxMutex implementation // ============================================================================ -//-------------------------------------------------------------------- -// wxMutex (Posix implementation) -//-------------------------------------------------------------------- +// ---------------------------------------------------------------------------- +// wxMutexInternal +// ---------------------------------------------------------------------------- class wxMutexInternal { public: + wxMutexInternal(); + ~wxMutexInternal(); + + wxMutexError Lock(); + wxMutexError TryLock(); + wxMutexError Unlock(); + +private: pthread_mutex_t m_mutex; + + friend class wxConditionInternal; }; -wxMutex::wxMutex() +wxMutexInternal::wxMutexInternal() { - m_internal = new wxMutexInternal; - // support recursive locks like Win32, i.e. a thread can lock a mutex which // it had itself already locked // @@ -174,64 +154,147 @@ wxMutex::wxMutex() pthread_mutexattr_init(&attr); pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); - pthread_mutex_init(&(m_internal->m_mutex), &attr); + pthread_mutex_init(&m_mutex, &attr); #elif defined(HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER) // we can use this only as initializer so we have to assign it first to a // temp var - assigning directly to m_mutex wouldn't even compile pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; - m_internal->m_mutex = mutex; + m_mutex = mutex; #else // no recursive mutexes - pthread_mutex_init(&(m_internal->m_mutex), NULL); + pthread_mutex_init(&m_mutex, NULL); + + // used by TryLock() below + #define NO_RECURSIVE_MUTEXES #endif // HAVE_PTHREAD_MUTEXATTR_T/... +} + +wxMutexInternal::~wxMutexInternal() +{ + pthread_mutex_destroy(&m_mutex); +} + +wxMutexError wxMutexInternal::Lock() +{ + int err = pthread_mutex_lock(&m_mutex); + switch ( err ) + { + case EDEADLK: + wxLogDebug(wxT("Locking this mutex would lead to deadlock!")); + return wxMUTEX_DEAD_LOCK; + + default: + wxFAIL_MSG( _T("unexpected pthread_mutex_lock() return") ); + // fall through + + case EINVAL: + wxLogDebug(_T("Failed to lock the mutex.")); + return wxMUTEX_MISC_ERROR; + + case 0: + return wxMUTEX_NO_ERROR; + } +} + +wxMutexError wxMutexInternal::TryLock() +{ + int err = pthread_mutex_trylock(&m_mutex); + switch ( err ) + { + case EBUSY: + return wxMUTEX_BUSY; + + default: + wxFAIL_MSG( _T("unexpected pthread_mutex_trylock() return") ); + // fall through + + case EINVAL: + wxLogDebug(_T("Failed to try to lock the mutex.")); + return wxMUTEX_MISC_ERROR; + + case 0: + return wxMUTEX_NO_ERROR; + } +} + +wxMutexError wxMutexInternal::Unlock() +{ + int err = pthread_mutex_unlock(&m_mutex); + switch ( err ) + { + case EPERM: + // we don't own the mutex + return wxMUTEX_UNLOCKED; + + default: + wxFAIL_MSG( _T("unexpected pthread_mutex_unlock() return") ); + // fall through + + case EINVAL: + wxLogDebug(_T("Failed to unlock the mutex.")); + return wxMUTEX_MISC_ERROR; + + case 0: + return wxMUTEX_NO_ERROR; + } +} + +// ---------------------------------------------------------------------------- +// wxMutex +// ---------------------------------------------------------------------------- + +// TODO: this is completely generic, move it to common code? + +wxMutex::wxMutex() +{ + m_internal = new wxMutexInternal; m_locked = 0; } wxMutex::~wxMutex() { - if (m_locked > 0) + if ( m_locked > 0 ) wxLogDebug(wxT("Freeing a locked mutex (%d locks)"), m_locked); - pthread_mutex_destroy( &(m_internal->m_mutex) ); delete m_internal; } wxMutexError wxMutex::Lock() { - int err = pthread_mutex_lock( &(m_internal->m_mutex) ); - if (err == EDEADLK) - { - wxLogDebug(wxT("Locking this mutex would lead to deadlock!")); + wxMutexError err = m_internal->Lock(); - return wxMUTEX_DEAD_LOCK; + if ( !err ) + { + m_locked++; } - m_locked++; - - return wxMUTEX_NO_ERROR; + return err; } wxMutexError wxMutex::TryLock() { - if (m_locked) + if ( m_locked ) { - return wxMUTEX_BUSY; +#ifdef NO_RECURSIVE_MUTEXES + return wxMUTEX_DEAD_LOCK; +#else // have recursive mutexes on this platform + // we will succeed in locking it when we have it already locked + return wxMUTEX_NO_ERROR; +#endif // recursive/non-recursive mutexes } - int err = pthread_mutex_trylock( &(m_internal->m_mutex) ); - switch (err) + wxMutexError err = m_internal->TryLock(); + if ( !err ) { - case EBUSY: return wxMUTEX_BUSY; + m_locked++; } - m_locked++; - - return wxMUTEX_NO_ERROR; + return err; } wxMutexError wxMutex::Unlock() { - if (m_locked > 0) + if ( m_locked > 0 ) { m_locked--; } @@ -242,308 +305,371 @@ wxMutexError wxMutex::Unlock() return wxMUTEX_UNLOCKED; } - pthread_mutex_unlock( &(m_internal->m_mutex) ); - - return wxMUTEX_NO_ERROR; + return m_internal->Unlock(); } -//-------------------------------------------------------------------- -// wxCondition (Posix implementation) -//-------------------------------------------------------------------- - -// The native POSIX condition variables are dumb: if the condition is signaled -// before another thread starts to wait on it, the signal is lost and so this -// other thread will be never woken up. It's much more convenient to us to -// remember that the condition was signaled and to return from Wait() -// immediately in this case (this is more like Win32 automatic event objects) +// =========================================================================== +// wxCondition implementation +// =========================================================================== -WX_DECLARE_LIST(pthread_mutex_t, wxMutexList); +// --------------------------------------------------------------------------- +// wxConditionInternal +// --------------------------------------------------------------------------- class wxConditionInternal { public: - wxConditionInternal(); + wxConditionInternal(wxMutex& mutex); ~wxConditionInternal(); void Wait(); - bool WaitWithTimeout(const timespec* ts); + + bool Wait( const timespec *ts ); void Signal(); - void Broadcast(); - void WaitDone(wxMutexList::Node *mutexnode); - wxMutexList::Node *ShouldWait(); - bool HasWaiters(); + void Broadcast(); private: - void LockAllMutexes(); // locks all mutexes on the list - void UnlockAllMutexes(); // unlocks mutexes after signaling / broadcasting - - // TRUE if condition was signaled while nobody waited for it - bool m_wasSignaled; - - // protects access to vars above - pthread_mutex_t m_mutexProtect; - - // the mutexes which are used for the condition variable - wxMutexList m_mutexes; + // get the POSIX mutex associated with us + pthread_mutex_t *GetMutex() const { return &m_mutex.m_internal->m_mutex; } - // the condition itself - pthread_cond_t m_condition; + wxMutex& m_mutex; + pthread_cond_t m_cond; }; -WX_DEFINE_LIST(wxMutexList); - -wxConditionInternal::wxConditionInternal() +wxConditionInternal::wxConditionInternal(wxMutex& mutex) + : m_mutex(mutex) { - m_wasSignaled = FALSE; - - if ( pthread_cond_init(&m_condition, (pthread_condattr_t *)NULL) != 0 ) + if ( pthread_cond_init( &m_cond, NULL ) != 0 ) { - // this is supposed to never happen - wxFAIL_MSG( _T("pthread_cond_init() failed") ); + wxLogDebug(_T("pthread_cond_init() failed")); } +} - if ( pthread_mutex_init(&m_mutexProtect, NULL) != 0 ) +wxConditionInternal::~wxConditionInternal() +{ + if ( pthread_cond_destroy( &m_cond ) != 0 ) { - // neither this - wxFAIL_MSG( _T("wxCondition: pthread_mutex_init() failed") ); + wxLogDebug(_T("pthread_cond_destroy() failed")); } - } -wxConditionInternal::~wxConditionInternal() +void wxConditionInternal::Wait() { - if ( pthread_cond_destroy( &m_condition ) != 0 ) + if ( pthread_cond_wait( &m_cond, GetMutex() ) != 0 ) { - wxLogDebug(_T("Failed to destroy condition variable (some " - "threads are probably still waiting on it?)")); + wxLogDebug(_T("pthread_cond_wait() failed")); } +} + +bool wxConditionInternal::Wait( const timespec *ts ) +{ + int result = pthread_cond_timedwait( &m_cond, GetMutex(), ts ); + if ( result == ETIMEDOUT ) + return FALSE; - for ( wxMutexList::Node *node = m_mutexes.GetFirst(); - node; - node = node->GetNext() ) + if ( result != 0 ) { - pthread_mutex_t *currentmutex = node->GetData(); - if ( pthread_mutex_unlock( currentmutex ) != 0 ) - { - wxLogDebug(_T("wxCondition: failed to unlock the mutex")); - } else { - delete currentmutex; - } + wxLogDebug(_T("pthread_cond_timedwait() failed")); } - m_mutexes.DeleteContents(TRUE); + return TRUE; +} - if ( pthread_mutex_destroy( &m_mutexProtect ) != 0 ) - { - wxLogDebug(_T("Failed to destroy mutex (it is probably locked)")); +void wxConditionInternal::Signal() +{ + int result = pthread_cond_signal( &m_cond ); + if ( result != 0 ) +{ + wxFAIL_MSG( _T("pthread_cond_signal() failed") ); } } -void wxConditionInternal::WaitDone(wxMutexList::Node *mutexnode) +void wxConditionInternal::Broadcast() +{ + int result = pthread_cond_broadcast( &m_cond ); + if ( result != 0 ) { - MutexLock lock(m_mutexProtect); + wxFAIL_MSG( _T("pthread_cond_broadcast() failed") ); + } +} - pthread_mutex_unlock(mutexnode->GetData()); - pthread_mutex_destroy(mutexnode->GetData()); - delete mutexnode->GetData(); - m_mutexes.DeleteNode(mutexnode); +// --------------------------------------------------------------------------- +// wxCondition +// --------------------------------------------------------------------------- +wxCondition::wxCondition(wxMutex& mutex) +{ + m_internal = new wxConditionInternal( mutex ); } -wxMutexList::Node *wxConditionInternal::ShouldWait() +wxCondition::~wxCondition() { - MutexLock lock(m_mutexProtect); - - if ( m_wasSignaled ) - { - // the condition was signaled before we started to wait, reset the - // flag and return - m_wasSignaled = FALSE; + delete m_internal; +} - return NULL; - } +void wxCondition::Wait() +{ + m_internal->Wait(); +} - // we start to wait for it +bool wxCondition::Wait( unsigned long timeout_millis ) +{ + wxLongLong curtime = wxGetLocalTimeMillis(); + curtime += timeout_millis; + wxLongLong temp = curtime / 1000; + int sec = temp.GetLo(); + temp = temp * 1000; + temp = curtime - temp; + int millis = temp.GetLo(); - pthread_mutex_t *waitmutex = new pthread_mutex_t; - if ( pthread_mutex_init(waitmutex, (pthread_mutexattr_t *)NULL) != 0 ) - { - // neither this - wxFAIL_MSG( _T("wxCondition: pthread_mutex_init() failed when starting waiting") ); - } + timespec tspec; - pthread_mutex_lock(waitmutex); + tspec.tv_sec = sec; + tspec.tv_nsec = millis * 1000L * 1000L; - return ( m_mutexes.Append(waitmutex) ); + return m_internal->Wait(&tspec); } -bool wxConditionInternal::HasWaiters() +void wxCondition::Signal() { - if ( m_mutexes.GetCount() ) - { - // someone waits for us, signal the condition normally - return TRUE; - } - - // nobody waits for us and may be never will - so just remember that the - // condition was signaled and don't do anything else - m_wasSignaled = TRUE; - - return FALSE; + m_internal->Signal(); } -void wxConditionInternal::Wait() +void wxCondition::Broadcast() { - wxMutexList::Node *ownmutexnode = ShouldWait(); + m_internal->Broadcast(); +} - if ( ownmutexnode ) - { - if ( pthread_cond_wait( &m_condition, ownmutexnode->GetData() ) != 0 ) - { - // not supposed to ever happen - wxFAIL_MSG( _T("pthread_cond_wait() failed") ); - } +// =========================================================================== +// wxSemaphore implementation +// =========================================================================== - WaitDone(ownmutexnode); - } -} +// --------------------------------------------------------------------------- +// wxSemaphoreInternal +// --------------------------------------------------------------------------- -bool wxConditionInternal::WaitWithTimeout(const timespec* ts) +class wxSemaphoreInternal { - bool ok; +public: + wxSemaphoreInternal( int initialcount, int maxcount ); - wxMutexList::Node *ownmutexnode = ShouldWait(); + void Wait(); + bool TryWait(); - if ( ownmutexnode ) - { - switch ( pthread_cond_timedwait( &m_condition, ownmutexnode->GetData(), ts ) ) - { - case 0: - // condition signaled - ok = TRUE; - break; + bool Wait( unsigned long timeout_millis ); - default: - wxLogDebug(_T("pthread_cond_timedwait() failed")); + void Post(); - // fall through +private: + wxMutex m_mutex; + wxCondition m_cond; - case ETIMEDOUT: - case EINTR: - // wait interrupted or timeout elapsed - ok = FALSE; - } - WaitDone(ownmutexnode); - } - else + int count, + maxcount; +}; + +wxSemaphoreInternal::wxSemaphoreInternal( int initialcount, int maxcount ) + : m_cond(m_mutex) +{ + + if ( (initialcount < 0) || ((maxcount > 0) && (initialcount > maxcount)) ) { - // the condition had already been signaled before - ok = TRUE; + wxFAIL_MSG( _T("wxSemaphore: invalid initial count") ); } - - return ok; + maxcount = maxcount; + count = initialcount; } -void wxConditionInternal::LockAllMutexes() +void wxSemaphoreInternal::Wait() { - wxMutexList::Node *mutexnode = m_mutexes.GetFirst(); - while ( mutexnode ) + wxMutexLocker locker(m_mutex); + + while ( count <= 0 ) { - pthread_mutex_lock(mutexnode->GetData()); - mutexnode = mutexnode->GetNext(); + m_cond.Wait(); } + + count--; } -void wxConditionInternal::UnlockAllMutexes() +bool wxSemaphoreInternal::TryWait() { - wxMutexList::Node *mutexnode = m_mutexes.GetFirst(); - while ( mutexnode ) - { - pthread_mutex_unlock(mutexnode->GetData()); - mutexnode = mutexnode->GetNext(); - } + wxMutexLocker locker(m_mutex); + + if ( count <= 0 ) + return FALSE; + + count--; + + return TRUE; } -void wxConditionInternal::Signal() +bool wxSemaphoreInternal::Wait( unsigned long timeout_millis ) { - // calls to HasWaiters() must be serialized - MutexLock lock(m_mutexProtect); + wxMutexLocker locker(m_mutex); - if ( HasWaiters() ) - { - // wait - LockAllMutexes(); + wxLongLong startTime = wxGetLocalTimeMillis(); - if ( pthread_cond_signal( &m_condition ) != 0 ) - { - // shouldn't ever happen - wxFAIL_MSG(_T("pthread_cond_signal() failed")); - } + while ( count <= 0 ) + { + wxLongLong elapsed = wxGetLocalTimeMillis() - startTime; + long remainingTime = (long)timeout_millis - (long)elapsed.GetLo(); + if ( remainingTime <= 0 ) + return FALSE; - UnlockAllMutexes(); + bool result = m_cond.Wait( remainingTime ); + if ( !result ) + return FALSE; } + + count--; + + return TRUE; } -void wxConditionInternal::Broadcast() +void wxSemaphoreInternal::Post() { - MutexLock lock(m_mutexProtect); + wxMutexLocker locker(m_mutex); - if ( HasWaiters() ) + if ( maxcount > 0 && count == maxcount ) { - LockAllMutexes(); + wxFAIL_MSG( _T("wxSemaphore::Post() overflow") ); + } - if ( pthread_cond_broadcast( &m_condition ) != 0 ) - { - // shouldn't ever happen - wxFAIL_MSG(_T("pthread_cond_broadcast() failed")); - } + count++; - UnlockAllMutexes(); - } + m_cond.Signal(); } -wxCondition::wxCondition() +// -------------------------------------------------------------------------- +// wxSemaphore +// -------------------------------------------------------------------------- + +wxSemaphore::wxSemaphore( int initialcount, int maxcount ) { - m_internal = new wxConditionInternal; + m_internal = new wxSemaphoreInternal( initialcount, maxcount ); } -wxCondition::~wxCondition() +wxSemaphore::~wxSemaphore() { delete m_internal; } -void wxCondition::Wait() +void wxSemaphore::Wait() { m_internal->Wait(); } -bool wxCondition::Wait(unsigned long sec, unsigned long nsec) +bool wxSemaphore::TryWait() { - timespec tspec; - - tspec.tv_sec = time(0L) + sec; // FIXME is time(0) correct here? - tspec.tv_nsec = nsec; - - return m_internal->WaitWithTimeout(&tspec); + return m_internal->TryWait(); } -void wxCondition::Signal() +bool wxSemaphore::Wait( unsigned long timeout_millis ) { - m_internal->Signal(); + return m_internal->Wait( timeout_millis ); } -void wxCondition::Broadcast() +void wxSemaphore::Post() { - m_internal->Broadcast(); + m_internal->Post(); } -//-------------------------------------------------------------------- -// wxThread (Posix implementation) -//-------------------------------------------------------------------- +// This class is used by wxThreadInternal to support Delete() on +// a detached thread +class wxRefCountedCondition +{ +public: + // start with a initial reference count of 1 + wxRefCountedCondition() + { + m_refCount = 1; + m_signaled = FALSE; + + m_mutex = new wxMutex(); + m_cond = new wxCondition( *m_mutex ); + } + + // increment the reference count + void AddRef() + { + wxMutexLocker locker( *m_mutex ); + + m_refCount++; + } + + // decrement the reference count if reference count is zero then delete the + // object + void DeleteRef() + { + bool shouldDelete = FALSE; + + m_mutex->Lock(); + + if ( --m_refCount == 0 ) + { + shouldDelete = TRUE; + } + + m_mutex->Unlock(); + + if ( shouldDelete ) + { + delete this; + } + } + + + // sets the object to signaled this signal will be a persistent signal all + // further Wait()s on the object will return without blocking + void SetSignaled() + { + wxMutexLocker locker( *m_mutex ); + + m_signaled = TRUE; + + m_cond->Broadcast(); + } + + // wait till the object is signaled if the object was already signaled then + // return immediately + void Wait() + { + wxMutexLocker locker( *m_mutex ); + + if ( !m_signaled ) + { + m_cond->Wait(); + } + } + +private: + int m_refCount; + + wxMutex *m_mutex; + wxCondition *m_cond; + + bool m_signaled; + + // Cannot delete this object directly, call DeleteRef() instead + ~wxRefCountedCondition() + { + delete m_cond; + delete m_mutex; + } + + // suppress gcc warning about the class having private dtor and not having + // friend (so what??) + friend class wxDummyFriend; +}; + +// =========================================================================== +// wxThread implementation +// =========================================================================== // the thread callback functions must have the C linkage extern "C" @@ -558,6 +684,10 @@ void *wxPthreadStart(void *ptr); } // extern "C" +// ---------------------------------------------------------------------------- +// wxThreadInternal +// ---------------------------------------------------------------------------- + class wxThreadInternal { public: @@ -575,7 +705,7 @@ public: // wake up threads waiting for our termination void SignalExit(); // wake up threads waiting for our start - void SignalRun() { m_condRun.Signal(); } + void SignalRun() { m_semRun.Post(); } // go to sleep until Resume() is called void Pause(); // resume the thread @@ -625,7 +755,7 @@ private: // this flag is set when the thread should terminate bool m_cancelled; - // this flag is set when the thread is blocking on m_condSuspend + // this flag is set when the thread is blocking on m_semSuspend bool m_isPaused; // the thread exit code - only used for joinable (!detached) threads and @@ -639,22 +769,18 @@ private: bool m_shouldBroadcast; bool m_isDetached; - // VZ: it's possible that we might do with less than three different - // condition objects - for example, m_condRun and m_condEnd a priori - // won't be used in the same time. But for now I prefer this may be a - // bit less efficient but safer solution of having distinct condition - // variables for each purpose. - - // this condition is signaled by Run() and the threads Entry() is not + // this semaphore is posted by Run() and the threads Entry() is not // called before it is done - wxCondition m_condRun; + wxSemaphore m_semRun; // this one is signaled when the thread should resume after having been // Pause()d - wxCondition m_condSuspend; + wxSemaphore m_semSuspend; // finally this one is signalled when the thread exits - wxCondition m_condEnd; + // we are using a reference counted condition to support + // Delete() for a detached thread + wxRefCountedCondition *m_condEnd; }; // ---------------------------------------------------------------------------- @@ -670,6 +796,8 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) { wxThreadInternal *pthread = thread->m_internal; + wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), pthread->GetId()); + // associate the thread pointer with the newly created thread so that // wxThread::This() will work int rc = pthread_setspecific(gs_keySelf, thread); @@ -690,8 +818,8 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) pthread_cleanup_push(wxPthreadCleanup, thread); #endif // HAVE_THREAD_CLEANUP_FUNCTIONS - // wait for the condition to be signaled from Run() - pthread->m_condRun.Wait(); + // wait for the semaphore to be posted from Run() + pthread->m_semRun.Wait(); // test whether we should run the run at all - may be it was deleted // before it started to Run()? @@ -785,17 +913,20 @@ wxThreadInternal::wxThreadInternal() m_threadId = 0; m_exitcode = 0; - // set to TRUE only when the thread starts waiting on m_condSuspend + // set to TRUE only when the thread starts waiting on m_semSuspend m_isPaused = FALSE; // defaults for joinable threads m_shouldBeJoined = TRUE; m_shouldBroadcast = TRUE; m_isDetached = FALSE; + + m_condEnd = new wxRefCountedCondition(); } wxThreadInternal::~wxThreadInternal() { + m_condEnd->DeleteRef(); } wxThreadError wxThreadInternal::Run() @@ -818,14 +949,22 @@ void wxThreadInternal::Wait() wxMutexGuiLeave(); bool isDetached = m_isDetached; - wxThreadIdType id = GetId(); + wxThreadIdType id = (wxThreadIdType) GetId(); wxLogTrace(TRACE_THREADS, _T("Starting to wait for thread %ld to exit."), id); // wait until the thread terminates (we're blocking in _another_ thread, // of course) - m_condEnd.Wait(); + + // a reference counting condition is used to handle the + // case where a detached thread deletes itself + // before m_condEnd->Wait() returns + // in this case the deletion of the condition object is deferred until + // all Wait()ing threads have finished calling DeleteRef() + m_condEnd->AddRef(); + m_condEnd->Wait(); + m_condEnd->DeleteRef(); wxLogTrace(TRACE_THREADS, _T("Finished waiting for thread %ld."), id); @@ -870,7 +1009,7 @@ void wxThreadInternal::SignalExit() wxLogTrace(TRACE_THREADS, _T("Thread %ld signals end condition."), GetId()); - m_condEnd.Broadcast(); + m_condEnd->SetSignaled(); } } @@ -883,8 +1022,8 @@ void wxThreadInternal::Pause() wxLogTrace(TRACE_THREADS, _T("Thread %ld goes to sleep."), GetId()); - // wait until the condition is signaled from Resume() - m_condSuspend.Wait(); + // wait until the semaphore is Post()ed from Resume() + m_semSuspend.Wait(); } void wxThreadInternal::Resume() @@ -899,7 +1038,7 @@ void wxThreadInternal::Resume() wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), GetId()); // wake up Pause() - m_condSuspend.Signal(); + m_semSuspend.Post(); // reset the flag SetReallyPaused(FALSE); @@ -1196,7 +1335,7 @@ unsigned int wxThread::GetPriority() const wxThreadIdType wxThread::GetId() const { - return m_internal->GetId(); + return (wxThreadIdType) m_internal->GetId(); } // ----------------------------------------------------------------------------- @@ -1300,7 +1439,7 @@ wxThreadError wxThread::Delete(ExitCode *rc) { case STATE_NEW: // we need to wake up the thread so that PthreadStart() will - // terminate - right now it's blocking on m_condRun + // terminate - right now it's blocking on m_semRun m_internal->SignalRun(); // fall through @@ -1483,7 +1622,8 @@ wxThread::~wxThread() // is not called for the joinable threads, so do it here if ( !m_isDetached ) { - MutexLock lock(gs_mutexDeleteThread); + wxMutexLocker lock( *gs_mutexDeleteThread ); + gs_nThreadsBeingDeleted--; wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."), @@ -1559,9 +1699,8 @@ bool wxThreadModule::OnInit() gs_mutexGui->Lock(); #endif // wxUSE_GUI - // under Solaris we get a warning from CC when using - // PTHREAD_MUTEX_INITIALIZER, so do it dynamically - pthread_mutex_init(&gs_mutexDeleteThread, NULL); + gs_mutexDeleteThread = new wxMutex(); + gs_condAllDeleted = new wxCondition( *gs_mutexDeleteThread ); return TRUE; } @@ -1572,18 +1711,19 @@ void wxThreadModule::OnExit() // are there any threads left which are being deleted right now? size_t nThreadsBeingDeleted; + { - MutexLock lock(gs_mutexDeleteThread); + wxMutexLocker lock( *gs_mutexDeleteThread ); nThreadsBeingDeleted = gs_nThreadsBeingDeleted; - } - if ( nThreadsBeingDeleted > 0 ) - { - wxLogTrace(TRACE_THREADS, _T("Waiting for %u threads to disappear"), - nThreadsBeingDeleted); + if ( nThreadsBeingDeleted > 0 ) +{ + wxLogTrace(TRACE_THREADS, _T("Waiting for %u threads to disappear"), + nThreadsBeingDeleted); - // have to wait until all of them disappear - gs_condAllDeleted->Wait(); + // have to wait until all of them disappear + gs_condAllDeleted->Wait(); + } } // terminate any threads left @@ -1610,6 +1750,9 @@ void wxThreadModule::OnExit() // and free TLD slot (void)pthread_key_delete(gs_keySelf); + + delete gs_condAllDeleted; + delete gs_mutexDeleteThread; } // ---------------------------------------------------------------------------- @@ -1618,12 +1761,7 @@ void wxThreadModule::OnExit() static void ScheduleThreadForDeletion() { - MutexLock lock(gs_mutexDeleteThread); - - if ( gs_nThreadsBeingDeleted == 0 ) - { - gs_condAllDeleted = new wxCondition; - } + wxMutexLocker lock( *gs_mutexDeleteThread ); gs_nThreadsBeingDeleted++; @@ -1636,17 +1774,15 @@ static void DeleteThread(wxThread *This) { // gs_mutexDeleteThread should be unlocked before signalling the condition // or wxThreadModule::OnExit() would deadlock - { - MutexLock lock(gs_mutexDeleteThread); + wxMutexLocker locker( *gs_mutexDeleteThread ); - wxLogTrace(TRACE_THREADS, _T("Thread %ld auto deletes."), This->GetId()); + wxLogTrace(TRACE_THREADS, _T("Thread %ld auto deletes."), This->GetId()); - delete This; + delete This; - wxCHECK_RET( gs_nThreadsBeingDeleted > 0, + wxCHECK_RET( gs_nThreadsBeingDeleted > 0, _T("no threads scheduled for deletion, yet we delete " "one?") ); - } wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."), gs_nThreadsBeingDeleted - 1); @@ -1655,9 +1791,6 @@ static void DeleteThread(wxThread *This) { // no more threads left, signal it gs_condAllDeleted->Signal(); - - delete gs_condAllDeleted; - gs_condAllDeleted = (wxCondition *)NULL; } }