// 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
/////////////////////////////////////////////////////////////////////////////
#include "wx/log.h"
#include "wx/intl.h"
#include "wx/dynarray.h"
+#include "wx/timer.h"
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <time.h>
-
#if HAVE_SCHED_H
#include <sched.h>
#endif
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
// ----------------------------------------------------------------------------
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
#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
//
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--;
}
return wxMUTEX_UNLOCKED;
}
- pthread_mutex_unlock( &(m_internal->m_mutex) );
-
- return wxMUTEX_NO_ERROR;
+ return m_internal->Unlock();
}
-//--------------------------------------------------------------------
-// wxCondition (Posix implementation)
-//--------------------------------------------------------------------
+// ===========================================================================
+// wxCondition 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)
+// ---------------------------------------------------------------------------
+// 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();
- bool ShouldWait();
- bool HasWaiters();
+ void Broadcast();
private:
- bool m_wasSignaled; // TRUE if condition was signaled while
- // nobody waited for it
- size_t m_nWaiters; // TRUE if someone already waits for us
+ // get the POSIX mutex associated with us
+ pthread_mutex_t *GetMutex() const { return &m_mutex.m_internal->m_mutex; }
- pthread_mutex_t m_mutexProtect; // protects access to vars above
-
- pthread_mutex_t m_mutex; // the mutex used with the condition
- pthread_cond_t m_condition; // the condition itself
+ wxMutex& m_mutex;
+ pthread_cond_t m_cond;
};
-wxConditionInternal::wxConditionInternal()
+wxConditionInternal::wxConditionInternal(wxMutex& mutex)
+ : m_mutex(mutex)
{
- m_wasSignaled = FALSE;
- m_nWaiters = 0;
-
- 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_mutex, (pthread_mutexattr_t *)NULL) != 0 ||
- 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"));
}
+}
- // initially the mutex is locked, so no thread can Signal() or Broadcast()
- // until another thread starts to Wait()
- if ( pthread_mutex_lock(&m_mutex) != 0 )
+void wxConditionInternal::Wait()
+{
+ if ( pthread_cond_wait( &m_cond, GetMutex() ) != 0 )
{
- wxFAIL_MSG( _T("wxCondition: pthread_mutex_lock() failed") );
+ wxLogDebug(_T("pthread_cond_wait() failed"));
}
}
-wxConditionInternal::~wxConditionInternal()
+bool wxConditionInternal::Wait( const timespec *ts )
{
- if ( pthread_cond_destroy( &m_condition ) != 0 )
+ int result = pthread_cond_timedwait( &m_cond, GetMutex(), ts );
+ if ( result == ETIMEDOUT )
+ return FALSE;
+
+ if ( result != 0 )
{
- wxLogDebug(_T("Failed to destroy condition variable (some "
- "threads are probably still waiting on it?)"));
+ wxLogDebug(_T("pthread_cond_timedwait() failed"));
}
- if ( pthread_mutex_unlock( &m_mutex ) != 0 )
- {
- wxLogDebug(_T("wxCondition: failed to unlock the mutex"));
+ return TRUE;
+}
+
+void wxConditionInternal::Signal()
+{
+ int result = pthread_cond_signal( &m_cond );
+ if ( result != 0 )
+{
+ wxFAIL_MSG( _T("pthread_cond_signal() failed") );
}
+}
- if ( pthread_mutex_destroy( &m_mutex ) != 0 ||
- pthread_mutex_destroy( &m_mutexProtect ) != 0 )
- {
- wxLogDebug(_T("Failed to destroy mutex (it is probably locked)"));
+void wxConditionInternal::Broadcast()
+{
+ int result = pthread_cond_broadcast( &m_cond );
+ if ( result != 0 )
+{
+ wxFAIL_MSG( _T("pthread_cond_broadcast() failed") );
}
}
-void wxConditionInternal::WaitDone()
+
+// ---------------------------------------------------------------------------
+// wxCondition
+// ---------------------------------------------------------------------------
+
+wxCondition::wxCondition(wxMutex& mutex)
{
- MutexLock lock(m_mutexProtect);
+ m_internal = new wxConditionInternal( mutex );
+}
- m_wasSignaled = FALSE;
- m_nWaiters--;
+wxCondition::~wxCondition()
+{
+ delete m_internal;
}
-bool wxConditionInternal::ShouldWait()
+void wxCondition::Wait()
{
- MutexLock lock(m_mutexProtect);
+ m_internal->Wait();
+}
- if ( m_wasSignaled )
- {
- // the condition was signaled before we started to wait, reset the
- // flag and return
- m_wasSignaled = FALSE;
+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();
- return FALSE;
- }
+ timespec tspec;
- // we start to wait for it
- m_nWaiters++;
+ tspec.tv_sec = sec;
+ tspec.tv_nsec = millis * 1000L * 1000L;
- return TRUE;
+ return m_internal->Wait(&tspec);
}
-bool wxConditionInternal::HasWaiters()
+void wxCondition::Signal()
{
- MutexLock lock(m_mutexProtect);
+ m_internal->Signal();
+}
- if ( m_nWaiters )
- {
- // someone waits for us, signal the condition normally
- return TRUE;
- }
+void wxCondition::Broadcast()
+{
+ m_internal->Broadcast();
+}
- // 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;
+// ===========================================================================
+// wxSemaphore implementation
+// ===========================================================================
- return FALSE;
-}
+// ---------------------------------------------------------------------------
+// wxSemaphoreInternal
+// ---------------------------------------------------------------------------
-void wxConditionInternal::Wait()
+class wxSemaphoreInternal
{
- if ( ShouldWait() )
+public:
+ wxSemaphoreInternal( int initialcount, int maxcount );
+
+ void Wait();
+ bool TryWait();
+
+ bool Wait( unsigned long timeout_millis );
+
+ void Post();
+
+private:
+ wxMutex m_mutex;
+ wxCondition m_cond;
+
+ int count,
+ maxcount;
+};
+
+wxSemaphoreInternal::wxSemaphoreInternal( int initialcount, int maxcount )
+ : m_cond(m_mutex)
+{
+
+ if ( (initialcount < 0) || ((maxcount > 0) && (initialcount > maxcount)) )
{
- if ( pthread_cond_wait( &m_condition, &m_mutex ) != 0 )
- {
- // not supposed to ever happen
- wxFAIL_MSG( _T("pthread_cond_wait() failed") );
- }
+ wxFAIL_MSG( _T("wxSemaphore: invalid initial count") );
}
- WaitDone();
+ maxcount = maxcount;
+ count = initialcount;
}
-bool wxConditionInternal::WaitWithTimeout(const timespec* ts)
+void wxSemaphoreInternal::Wait()
{
- bool ok;
+ wxMutexLocker locker(m_mutex);
- if ( ShouldWait() )
+ while ( count <= 0 )
{
- switch ( pthread_cond_timedwait( &m_condition, &m_mutex, ts ) )
- {
- case 0:
- // condition signaled
- ok = TRUE;
- break;
+ m_cond.Wait();
+ }
- default:
- wxLogDebug(_T("pthread_cond_timedwait() failed"));
+ count--;
+}
- // fall through
+bool wxSemaphoreInternal::TryWait()
+{
+ wxMutexLocker locker(m_mutex);
- case ETIMEDOUT:
- case EINTR:
- // wait interrupted or timeout elapsed
- ok = FALSE;
- }
- }
- else
- {
- // the condition had already been signaled before
- ok = TRUE;
- }
+ if ( count <= 0 )
+ return FALSE;
- WaitDone();
+ count--;
- return ok;
+ return TRUE;
}
-void wxConditionInternal::Signal()
+bool wxSemaphoreInternal::Wait( unsigned long timeout_millis )
{
- if ( HasWaiters() )
+ wxMutexLocker locker(m_mutex);
+
+ wxLongLong startTime = wxGetLocalTimeMillis();
+
+ while ( count <= 0 )
{
- MutexLock lock(m_mutex);
+ wxLongLong elapsed = wxGetLocalTimeMillis() - startTime;
+ long remainingTime = (long)timeout_millis - (long)elapsed.GetLo();
+ if ( remainingTime <= 0 )
+ return FALSE;
- if ( pthread_cond_signal( &m_condition ) != 0 )
- {
- // shouldn't ever happen
- wxFAIL_MSG(_T("pthread_cond_signal() failed"));
- }
+ bool result = m_cond.Wait( remainingTime );
+ if ( !result )
+ return FALSE;
}
+
+ count--;
+
+ return TRUE;
}
-void wxConditionInternal::Broadcast()
+void wxSemaphoreInternal::Post()
{
- if ( HasWaiters() )
- {
- MutexLock lock(m_mutex);
+ wxMutexLocker locker(m_mutex);
- if ( pthread_cond_broadcast( &m_condition ) != 0 )
- {
- // shouldn't ever happen
- wxFAIL_MSG(_T("pthread_cond_broadcast() failed"));
- }
+ if ( maxcount > 0 && count == maxcount )
+ {
+ wxFAIL_MSG( _T("wxSemaphore::Post() overflow") );
}
+
+ count++;
+
+ 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"
} // extern "C"
+// ----------------------------------------------------------------------------
+// wxThreadInternal
+// ----------------------------------------------------------------------------
+
class wxThreadInternal
{
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
// 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
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;
};
// ----------------------------------------------------------------------------
{
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);
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()?
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()
wxMutexGuiLeave();
bool isDetached = m_isDetached;
-#ifdef __VMS
- long long id = (long long)GetId();
-#else
- long id = (long)GetId();
-#endif
- wxLogTrace(TRACE_THREADS, _T("Starting to wait for thread %ld to exit."),
- id);
+ 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);
wxLogTrace(TRACE_THREADS, _T("Thread %ld signals end condition."),
GetId());
- m_condEnd.Broadcast();
+ m_condEnd->SetSignaled();
}
}
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()
wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), GetId());
// wake up Pause()
- m_condSuspend.Signal();
+ m_semSuspend.Post();
// reset the flag
SetReallyPaused(FALSE);
return -1;
}
+#ifdef __VMS
+ // VMS is a 64 bit system and threads have 64 bit pointers.
+ // ??? also needed for other systems????
+unsigned long long wxThread::GetCurrentId()
+{
+ return (unsigned long long)pthread_self();
+#else
unsigned long wxThread::GetCurrentId()
{
return (unsigned long)pthread_self();
+#endif
}
bool wxThread::SetConcurrency(size_t level)
return m_internal->GetPriority();
}
-#ifdef __VMS
-unsigned long long wxThread::GetId() const
+wxThreadIdType wxThread::GetId() const
{
- return (unsigned long long)m_internal->GetId();
-#else
-unsigned long wxThread::GetId() const
-{
- return (unsigned long)m_internal->GetId();
-#endif
+ return (wxThreadIdType) m_internal->GetId();
}
// -----------------------------------------------------------------------------
{
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
// 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."),
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;
}
// 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
// and free TLD slot
(void)pthread_key_delete(gs_keySelf);
+
+ delete gs_condAllDeleted;
+ delete gs_mutexDeleteThread;
}
// ----------------------------------------------------------------------------
static void ScheduleThreadForDeletion()
{
- MutexLock lock(gs_mutexDeleteThread);
-
- if ( gs_nThreadsBeingDeleted == 0 )
- {
- gs_condAllDeleted = new wxCondition;
- }
+ wxMutexLocker lock( *gs_mutexDeleteThread );
gs_nThreadsBeingDeleted++;
{
// 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);
{
// no more threads left, signal it
gs_condAllDeleted->Signal();
-
- delete gs_condAllDeleted;
- gs_condAllDeleted = (wxCondition *)NULL;
}
}
projects / wxWidgets.git / blobdiff