#if wxUSE_THREADS
#include "wx/thread.h"
+#include "wx/except.h"
#ifndef WX_PRECOMP
+ #include "wx/app.h"
#include "wx/dynarray.h"
#include "wx/intl.h"
#include "wx/log.h"
#include <pthread.h>
#include <errno.h>
#include <time.h>
+#include <sys/time.h> // needed for at least __QNX__
#ifdef HAVE_SCHED_H
#include <sched.h>
#endif
// we use wxFFile under Linux in GetCPUCount()
#ifdef __LINUX__
#include "wx/ffile.h"
- // For setpriority.
- #include <sys/time.h>
- #include <sys/resource.h>
+ #include <sys/resource.h> // for setpriority()
#endif
-#ifdef __VMS
- #define THR_ID(thr) ((long long)(thr)->GetId())
-#else
- #define THR_ID(thr) ((long)(thr)->GetId())
-#endif
+#define THR_ID_CAST(id) (reinterpret_cast<void*>(id))
+#define THR_ID(thr) THR_ID_CAST((thr)->GetId())
// ----------------------------------------------------------------------------
// constants
static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1;
// trace mask for wxThread operations
-#define TRACE_THREADS _T("thread")
+#define TRACE_THREADS wxT("thread")
// you can get additional debugging messages for the semaphore operations
-#define TRACE_SEMA _T("semaphore")
+#define TRACE_SEMA wxT("semaphore")
// ----------------------------------------------------------------------------
// private functions
static wxMutex *gs_mutexAllThreads = NULL;
// the id of the main thread
-static pthread_t gs_tidMain = (pthread_t)-1;
+//
+// we suppose that 0 is not a valid pthread_t value but in principle this might
+// be false (e.g. if it's a selector-like value), wxThread::IsMain() would need
+// to be updated in such case
+wxThreadIdType wxThread::ms_idMainThread = 0;
// the key for the pointer to the associated wxThread object
static pthread_key_t gs_keySelf;
static size_t gs_nThreadsBeingDeleted = 0;
// a mutex to protect gs_nThreadsBeingDeleted
-static wxMutex *gs_mutexDeleteThread = (wxMutex *)NULL;
+static wxMutex *gs_mutexDeleteThread = NULL;
// and a condition variable which will be signaled when all
// gs_nThreadsBeingDeleted will have been deleted
-static wxCondition *gs_condAllDeleted = (wxCondition *)NULL;
+static wxCondition *gs_condAllDeleted = NULL;
+#ifndef __WXOSX__
// this mutex must be acquired before any call to a GUI function
// (it's not inside #if wxUSE_GUI because this file is compiled as part
// of wxBase)
static wxMutex *gs_mutexGui = NULL;
+#endif
// when we wait for a thread to exit, we're blocking on a condition which the
// thread signals in its SignalExit() method -- but this condition can't be a
~wxMutexInternal();
wxMutexError Lock();
+ wxMutexError Lock(unsigned long ms);
wxMutexError TryLock();
wxMutexError Unlock();
bool IsOk() const { return m_isOk; }
+private:
+ // convert the result of pthread_mutex_[timed]lock() call to wx return code
+ wxMutexError HandleLockResult(int err);
+
private:
pthread_mutex_t m_mutex;
bool m_isOk;
+ wxMutexType m_type;
+ unsigned long m_owningThread;
// wxConditionInternal uses our m_mutex
friend class wxConditionInternal;
wxMutexInternal::wxMutexInternal(wxMutexType mutexType)
{
+ m_type = mutexType;
+ m_owningThread = 0;
+
int err;
switch ( mutexType )
{
break;
default:
- wxFAIL_MSG( _T("unknown mutex type") );
+ wxFAIL_MSG( wxT("unknown mutex type") );
// fall through
case wxMUTEX_DEFAULT:
wxMutexError wxMutexInternal::Lock()
{
- int err = pthread_mutex_lock(&m_mutex);
+ if ((m_type == wxMUTEX_DEFAULT) && (m_owningThread != 0))
+ {
+ if (m_owningThread == wxThread::GetCurrentId())
+ return wxMUTEX_DEAD_LOCK;
+ }
+
+ return HandleLockResult(pthread_mutex_lock(&m_mutex));
+}
+
+wxMutexError wxMutexInternal::Lock(unsigned long ms)
+{
+#ifdef HAVE_PTHREAD_MUTEX_TIMEDLOCK
+ static const long MSEC_IN_SEC = 1000;
+ static const long NSEC_IN_MSEC = 1000000;
+ static const long NSEC_IN_USEC = 1000;
+ static const long NSEC_IN_SEC = MSEC_IN_SEC * NSEC_IN_MSEC;
+
+ time_t seconds = ms/MSEC_IN_SEC;
+ long nanoseconds = (ms % MSEC_IN_SEC) * NSEC_IN_MSEC;
+ timespec ts = { 0, 0 };
+
+ // normally we should use clock_gettime(CLOCK_REALTIME) here but this
+ // function is in librt and we don't link with it currently, so use
+ // gettimeofday() instead -- if it turns out that this is really too
+ // imprecise, we should modify configure to check if clock_gettime() is
+ // available and whether it requires -lrt and use it instead
+#if 0
+ if ( clock_gettime(CLOCK_REALTIME, &ts) == 0 )
+ {
+ }
+#else
+ struct timeval tv;
+ if ( wxGetTimeOfDay(&tv) != -1 )
+ {
+ ts.tv_sec = tv.tv_sec;
+ ts.tv_nsec = tv.tv_usec*NSEC_IN_USEC;
+ }
+#endif
+ else // fall back on system timer
+ {
+ ts.tv_sec = time(NULL);
+ }
+
+ ts.tv_sec += seconds;
+ ts.tv_nsec += nanoseconds;
+ if ( ts.tv_nsec > NSEC_IN_SEC )
+ {
+ ts.tv_sec += 1;
+ ts.tv_nsec -= NSEC_IN_SEC;
+ }
+
+ return HandleLockResult(pthread_mutex_timedlock(&m_mutex, &ts));
+#else // !HAVE_PTHREAD_MUTEX_TIMEDLOCK
+ wxUnusedVar(ms);
+
+ return wxMUTEX_MISC_ERROR;
+#endif // HAVE_PTHREAD_MUTEX_TIMEDLOCK/!HAVE_PTHREAD_MUTEX_TIMEDLOCK
+}
+
+wxMutexError wxMutexInternal::HandleLockResult(int err)
+{
+ // wxPrintf( "err %d\n", err );
+
switch ( err )
{
case EDEADLK:
// only error checking mutexes return this value and so it's an
// unexpected situation -- hence use assert, not wxLogDebug
- wxFAIL_MSG( _T("mutex deadlock prevented") );
+ wxFAIL_MSG( wxT("mutex deadlock prevented") );
return wxMUTEX_DEAD_LOCK;
case EINVAL:
- wxLogDebug(_T("pthread_mutex_lock(): mutex not initialized."));
+ wxLogDebug(wxT("pthread_mutex_[timed]lock(): mutex not initialized"));
break;
+ case ETIMEDOUT:
+ return wxMUTEX_TIMEOUT;
+
case 0:
+ if (m_type == wxMUTEX_DEFAULT)
+ m_owningThread = wxThread::GetCurrentId();
return wxMUTEX_NO_ERROR;
default:
- wxLogApiError(_T("pthread_mutex_lock()"), err);
+ wxLogApiError(wxT("pthread_mutex_[timed]lock()"), err);
}
return wxMUTEX_MISC_ERROR;
}
+
wxMutexError wxMutexInternal::TryLock()
{
int err = pthread_mutex_trylock(&m_mutex);
return wxMUTEX_BUSY;
case EINVAL:
- wxLogDebug(_T("pthread_mutex_trylock(): mutex not initialized."));
+ wxLogDebug(wxT("pthread_mutex_trylock(): mutex not initialized."));
break;
case 0:
+ if (m_type == wxMUTEX_DEFAULT)
+ m_owningThread = wxThread::GetCurrentId();
return wxMUTEX_NO_ERROR;
default:
- wxLogApiError(_T("pthread_mutex_trylock()"), err);
+ wxLogApiError(wxT("pthread_mutex_trylock()"), err);
}
return wxMUTEX_MISC_ERROR;
wxMutexError wxMutexInternal::Unlock()
{
+ m_owningThread = 0;
+
int err = pthread_mutex_unlock(&m_mutex);
switch ( err )
{
return wxMUTEX_UNLOCKED;
case EINVAL:
- wxLogDebug(_T("pthread_mutex_unlock(): mutex not initialized."));
+ wxLogDebug(wxT("pthread_mutex_unlock(): mutex not initialized."));
break;
case 0:
return wxMUTEX_NO_ERROR;
default:
- wxLogApiError(_T("pthread_mutex_unlock()"), err);
+ wxLogApiError(wxT("pthread_mutex_unlock()"), err);
}
return wxMUTEX_MISC_ERROR;
if ( !m_isOk )
{
- wxLogApiError(_T("pthread_cond_init()"), err);
+ wxLogApiError(wxT("pthread_cond_init()"), err);
}
}
int err = pthread_cond_destroy(&m_cond);
if ( err != 0 )
{
- wxLogApiError(_T("pthread_cond_destroy()"), err);
+ wxLogApiError(wxT("pthread_cond_destroy()"), err);
}
}
}
int err = pthread_cond_wait(&m_cond, GetPMutex());
if ( err != 0 )
{
- wxLogApiError(_T("pthread_cond_wait()"), err);
+ wxLogApiError(wxT("pthread_cond_wait()"), err);
return wxCOND_MISC_ERROR;
}
return wxCOND_NO_ERROR;
default:
- wxLogApiError(_T("pthread_cond_timedwait()"), err);
+ wxLogApiError(wxT("pthread_cond_timedwait()"), err);
}
return wxCOND_MISC_ERROR;
int err = pthread_cond_signal(&m_cond);
if ( err != 0 )
{
- wxLogApiError(_T("pthread_cond_signal()"), err);
+ wxLogApiError(wxT("pthread_cond_signal()"), err);
return wxCOND_MISC_ERROR;
}
int err = pthread_cond_broadcast(&m_cond);
if ( err != 0 )
{
- wxLogApiError(_T("pthread_cond_broadcast()"), err);
+ wxLogApiError(wxT("pthread_cond_broadcast()"), err);
return wxCOND_MISC_ERROR;
}
if ( (initialcount < 0 || maxcount < 0) ||
((maxcount > 0) && (initialcount > maxcount)) )
{
- wxFAIL_MSG( _T("wxSemaphore: invalid initial or maximal count") );
+ wxFAIL_MSG( wxT("wxSemaphore: invalid initial or maximal count") );
m_isOk = false;
}
while ( m_count == 0 )
{
wxLogTrace(TRACE_SEMA,
- _T("Thread %ld waiting for semaphore to become signalled"),
- wxThread::GetCurrentId());
+ wxT("Thread %p waiting for semaphore to become signalled"),
+ THR_ID_CAST(wxThread::GetCurrentId()));
if ( m_cond.Wait() != wxCOND_NO_ERROR )
return wxSEMA_MISC_ERROR;
wxLogTrace(TRACE_SEMA,
- _T("Thread %ld finished waiting for semaphore, count = %lu"),
- wxThread::GetCurrentId(), (unsigned long)m_count);
+ wxT("Thread %p finished waiting for semaphore, count = %lu"),
+ THR_ID_CAST(wxThread::GetCurrentId()), (unsigned long)m_count);
}
m_count--;
m_count++;
wxLogTrace(TRACE_SEMA,
- _T("Thread %ld about to signal semaphore, count = %lu"),
- wxThread::GetCurrentId(), (unsigned long)m_count);
+ wxT("Thread %p about to signal semaphore, count = %lu"),
+ THR_ID_CAST(wxThread::GetCurrentId()), (unsigned long)m_count);
return m_cond.Signal() == wxCOND_NO_ERROR ? wxSEMA_NO_ERROR
: wxSEMA_MISC_ERROR;
wxThreadState GetState() const { return m_state; }
void SetState(wxThreadState state)
{
-#ifdef __WXDEBUG__
- static const wxChar *stateNames[] =
+#if wxUSE_LOG_TRACE
+ static const wxChar *const stateNames[] =
{
- _T("NEW"),
- _T("RUNNING"),
- _T("PAUSED"),
- _T("EXITED"),
+ wxT("NEW"),
+ wxT("RUNNING"),
+ wxT("PAUSED"),
+ wxT("EXITED"),
};
- wxLogTrace(TRACE_THREADS, _T("Thread %ld: %s => %s."),
- (long)GetId(), stateNames[m_state], stateNames[state]);
-#endif // __WXDEBUG__
+ wxLogTrace(TRACE_THREADS, wxT("Thread %p: %s => %s."),
+ THR_ID(this), stateNames[m_state], stateNames[state]);
+#endif // wxUSE_LOG_TRACE
m_state = state;
}
{
wxThreadInternal *pthread = thread->m_internal;
- wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), THR_ID(pthread));
+ wxLogTrace(TRACE_THREADS, wxT("Thread %p started."), THR_ID(pthread));
// associate the thread pointer with the newly created thread so that
// wxThread::This() will work
{
// call the main entry
wxLogTrace(TRACE_THREADS,
- _T("Thread %ld about to enter its Entry()."),
+ wxT("Thread %p about to enter its Entry()."),
THR_ID(pthread));
- pthread->m_exitcode = thread->Entry();
+ wxTRY
+ {
+ pthread->m_exitcode = thread->Entry();
- wxLogTrace(TRACE_THREADS,
- _T("Thread %ld Entry() returned %lu."),
- THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode));
+ wxLogTrace(TRACE_THREADS,
+ wxT("Thread %p Entry() returned %lu."),
+ THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode));
+ }
+ wxCATCH_ALL( wxTheApp->OnUnhandledException(); )
{
wxCriticalSectionLocker lock(thread->m_critsect);
void wxThreadInternal::Wait()
{
- wxCHECK_RET( !m_isDetached, _T("can't wait for a detached thread") );
+ wxCHECK_RET( !m_isDetached, wxT("can't wait for a detached thread") );
// if the thread we're waiting for is waiting for the GUI mutex, we will
// deadlock so make sure we release it temporarily
if ( wxThread::IsMain() )
+ {
+#ifdef __WXOSX__
+ // give the thread we're waiting for chance to do the GUI call
+ // it might be in, we don't do this conditionally as the to be waited on
+ // thread might have to acquire the mutex later but before terminating
+ if ( wxGuiOwnedByMainThread() )
+ wxMutexGuiLeave();
+#else
wxMutexGuiLeave();
+#endif
+ }
wxLogTrace(TRACE_THREADS,
- _T("Starting to wait for thread %ld to exit."),
+ wxT("Starting to wait for thread %p to exit."),
THR_ID(this));
// to avoid memory leaks we should call pthread_join(), but it must only be
}
}
+#ifndef __WXOSX__
// reacquire GUI mutex
if ( wxThread::IsMain() )
wxMutexGuiEnter();
+#endif
}
void wxThreadInternal::Pause()
wxT("thread must first be paused with wxThread::Pause().") );
wxLogTrace(TRACE_THREADS,
- _T("Thread %ld goes to sleep."), THR_ID(this));
+ wxT("Thread %p goes to sleep."), THR_ID(this));
// wait until the semaphore is Post()ed from Resume()
m_semSuspend.Wait();
if ( IsReallyPaused() )
{
wxLogTrace(TRACE_THREADS,
- _T("Waking up thread %ld"), THR_ID(this));
+ wxT("Waking up thread %p"), THR_ID(this));
// wake up Pause()
m_semSuspend.Post();
else
{
wxLogTrace(TRACE_THREADS,
- _T("Thread %ld is not yet really paused"), THR_ID(this));
+ wxT("Thread %p is not yet really paused"), THR_ID(this));
}
SetState(STATE_RUNNING);
return (wxThread *)pthread_getspecific(gs_keySelf);
}
-bool wxThread::IsMain()
-{
- return (bool)pthread_equal(pthread_self(), gs_tidMain) || gs_tidMain == (pthread_t)-1;
-}
-
void wxThread::Yield()
{
#ifdef HAVE_SCHED_YIELD
#endif
}
-void wxThread::Sleep(unsigned long milliseconds)
-{
- wxMilliSleep(milliseconds);
-}
-
int wxThread::GetCPUCount()
{
-#if defined(__LINUX__) && wxUSE_FFILE
+#if defined(_SC_NPROCESSORS_ONLN)
+ // this works for Solaris and Linux 2.6
+ int rc = sysconf(_SC_NPROCESSORS_ONLN);
+ if ( rc != -1 )
+ {
+ return rc;
+ }
+#elif defined(__LINUX__) && wxUSE_FFILE
// read from proc (can't use wxTextFile here because it's a special file:
// it has 0 size but still can be read from)
wxLogNull nolog;
- wxFFile file(_T("/proc/cpuinfo"));
+ wxFFile file(wxT("/proc/cpuinfo"));
if ( file.IsOpened() )
{
// slurp the whole file
if ( file.ReadAll(&s) )
{
// (ab)use Replace() to find the number of "processor: num" strings
- size_t count = s.Replace(_T("processor\t:"), _T(""));
+ size_t count = s.Replace(wxT("processor\t:"), wxT(""));
if ( count > 0 )
{
return count;
}
- wxLogDebug(_T("failed to parse /proc/cpuinfo"));
+ wxLogDebug(wxT("failed to parse /proc/cpuinfo"));
}
else
{
- wxLogDebug(_T("failed to read /proc/cpuinfo"));
+ wxLogDebug(wxT("failed to read /proc/cpuinfo"));
}
}
-#elif defined(_SC_NPROCESSORS_ONLN)
- // this works for Solaris
- int rc = sysconf(_SC_NPROCESSORS_ONLN);
- if ( rc != -1 )
- {
- return rc;
- }
#endif // different ways to get number of CPUs
// unknown
return -1;
}
-// VMS is a 64 bit system and threads have 64 bit pointers.
-// FIXME: also needed for other systems????
-#ifdef __VMS
-unsigned long long wxThread::GetCurrentId()
+wxThreadIdType wxThread::GetCurrentId()
{
- return (unsigned long long)pthread_self();
+ return (wxThreadIdType)pthread_self();
}
-#else // !__VMS
-
-unsigned long wxThread::GetCurrentId()
-{
- return (unsigned long)pthread_self();
-}
-
-#endif // __VMS/!__VMS
-
bool wxThread::SetConcurrency(size_t level)
{
int rc = thr_setconcurrency(level);
if ( rc != 0 )
{
- wxLogSysError(rc, _T("thr_setconcurrency() failed"));
+ wxLogSysError(rc, wxT("thr_setconcurrency() failed"));
}
return rc == 0;
struct sched_param sp;
if ( pthread_attr_getschedparam(&attr, &sp) != 0 )
{
- wxFAIL_MSG(_T("pthread_attr_getschedparam() failed"));
+ wxFAIL_MSG(wxT("pthread_attr_getschedparam() failed"));
}
sp.sched_priority = min_prio + (prio*(max_prio - min_prio))/100;
if ( pthread_attr_setschedparam(&attr, &sp) != 0 )
{
- wxFAIL_MSG(_T("pthread_attr_setschedparam(priority) failed"));
+ wxFAIL_MSG(wxT("pthread_attr_setschedparam(priority) failed"));
}
}
#endif // HAVE_THREAD_PRIORITY_FUNCTIONS
// this will make the threads created by this process really concurrent
if ( pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) != 0 )
{
- wxFAIL_MSG(_T("pthread_attr_setscope(PTHREAD_SCOPE_SYSTEM) failed"));
+ wxFAIL_MSG(wxT("pthread_attr_setscope(PTHREAD_SCOPE_SYSTEM) failed"));
}
#endif // HAVE_PTHREAD_ATTR_SETSCOPE
{
if ( pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0 )
{
- wxFAIL_MSG(_T("pthread_attr_setdetachstate(DETACHED) failed"));
+ wxFAIL_MSG(wxT("pthread_attr_setdetachstate(DETACHED) failed"));
}
// never try to join detached threads
if ( pthread_attr_destroy(&attr) != 0 )
{
- wxFAIL_MSG(_T("pthread_attr_destroy() failed"));
+ wxFAIL_MSG(wxT("pthread_attr_destroy() failed"));
}
if ( rc != 0 )
// map wx priorites WXTHREAD_MIN_PRIORITY..WXTHREAD_MAX_PRIORITY
// to Unix priorities 20..-20
- if ( setpriority(PRIO_PROCESS, 0, -(2*prio)/5 + 20) == -1 )
+ if ( setpriority(PRIO_PROCESS, 0, -(2*(int)prio)/5 + 20) == -1 )
{
wxLogError(_("Failed to set thread priority %d."), prio);
}
wxThreadError wxThread::Pause()
{
wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
- _T("a thread can't pause itself") );
+ wxT("a thread can't pause itself") );
wxCriticalSectionLocker lock(m_critsect);
wxThreadError wxThread::Resume()
{
wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
- _T("a thread can't resume itself") );
+ wxT("a thread can't resume itself") );
wxCriticalSectionLocker lock(m_critsect);
switch ( state )
{
case STATE_PAUSED:
- wxLogTrace(TRACE_THREADS, _T("Thread %ld suspended, resuming."),
- GetId());
+ wxLogTrace(TRACE_THREADS, wxT("Thread %p suspended, resuming."),
+ THR_ID(this));
m_internal->Resume();
return wxTHREAD_NO_ERROR;
case STATE_EXITED:
- wxLogTrace(TRACE_THREADS, _T("Thread %ld exited, won't resume."),
- GetId());
+ wxLogTrace(TRACE_THREADS, wxT("Thread %p exited, won't resume."),
+ THR_ID(this));
return wxTHREAD_NO_ERROR;
default:
- wxLogDebug(_T("Attempt to resume a thread which is not paused."));
+ wxLogDebug(wxT("Attempt to resume a thread which is not paused."));
return wxTHREAD_MISC_ERROR;
}
// exiting thread
// -----------------------------------------------------------------------------
-wxThread::ExitCode wxThread::Wait()
+wxThread::ExitCode wxThread::Wait(wxThreadWait WXUNUSED(waitMode))
{
wxCHECK_MSG( This() != this, (ExitCode)-1,
- _T("a thread can't wait for itself") );
+ wxT("a thread can't wait for itself") );
wxCHECK_MSG( !m_isDetached, (ExitCode)-1,
- _T("can't wait for detached thread") );
+ wxT("can't wait for detached thread") );
m_internal->Wait();
return m_internal->GetExitCode();
}
-wxThreadError wxThread::Delete(ExitCode *rc)
+wxThreadError wxThread::Delete(ExitCode *rc, wxThreadWait WXUNUSED(waitMode))
{
wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
- _T("a thread can't delete itself") );
+ wxT("a thread can't delete itself") );
bool isDetached = m_isDetached;
m_critsect.Leave();
+ OnDelete();
+
switch ( state )
{
case STATE_NEW:
//else: can't wait for detached threads
}
+ if (state == STATE_NEW)
+ return wxTHREAD_MISC_ERROR;
+ // for coherency with the MSW implementation, signal the user that
+ // Delete() was called on a thread which didn't start to run yet.
+
return wxTHREAD_NO_ERROR;
}
wxThreadError wxThread::Kill()
{
wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
- _T("a thread can't kill itself") );
+ wxT("a thread can't kill itself") );
+
+ OnKill();
switch ( m_internal->GetState() )
{
void wxThread::Exit(ExitCode status)
{
wxASSERT_MSG( This() == this,
- _T("wxThread::Exit() can only be called in the context of the same thread") );
+ wxT("wxThread::Exit() can only be called in the context of the same thread") );
if ( m_isDetached )
{
// might deadlock if, for example, it signals a condition in OnExit() (a
// common case) while the main thread calls any of functions entering
// m_critsect on us (almost all of them do)
- OnExit();
+ wxTRY
+ {
+ OnExit();
+ }
+ wxCATCH_ALL( wxTheApp->OnUnhandledException(); )
// delete C++ thread object if this is a detached thread - user is
// responsible for doing this for joinable ones
// terminate the thread (pthread_exit() never returns)
pthread_exit(status);
- wxFAIL_MSG(_T("pthread_exit() failed"));
+ wxFAIL_MSG(wxT("pthread_exit() failed"));
}
// also test whether we were paused
bool wxThread::TestDestroy()
{
wxASSERT_MSG( This() == this,
- _T("wxThread::TestDestroy() can only be called in the context of the same thread") );
+ wxT("wxThread::TestDestroy() can only be called in the context of the same thread") );
m_critsect.Enter();
wxThread::~wxThread()
{
-#ifdef __WXDEBUG__
m_critsect.Enter();
// check that the thread either exited or couldn't be created
if ( m_internal->GetState() != STATE_EXITED &&
m_internal->GetState() != STATE_NEW )
{
- wxLogDebug(_T("The thread %ld is being destroyed although it is still running! The application may crash."),
- (long)GetId());
+ wxLogDebug(wxT("The thread %p is being destroyed although it is still running! The application may crash."),
+ THR_ID(this));
}
m_critsect.Leave();
-#endif // __WXDEBUG__
delete m_internal;
// wxThreadModule
//--------------------------------------------------------------------
+#ifdef __WXOSX__
+void wxOSXThreadModuleOnInit();
+void wxOSXThreadModuleOnExit();
+#endif
+
class wxThreadModule : public wxModule
{
public:
return false;
}
- gs_tidMain = pthread_self();
+ wxThread::ms_idMainThread = wxThread::GetCurrentId();
gs_mutexAllThreads = new wxMutex();
+#ifdef __WXOSX__
+ wxOSXThreadModuleOnInit();
+#else
gs_mutexGui = new wxMutex();
gs_mutexGui->Lock();
+#endif
gs_mutexDeleteThread = new wxMutex();
gs_condAllDeleted = new wxCondition(*gs_mutexDeleteThread);
if ( nThreadsBeingDeleted > 0 )
{
wxLogTrace(TRACE_THREADS,
- _T("Waiting for %lu threads to disappear"),
+ wxT("Waiting for %lu threads to disappear"),
(unsigned long)nThreadsBeingDeleted);
// have to wait until all of them disappear
delete gs_mutexAllThreads;
+#ifdef __WXOSX__
+ wxOSXThreadModuleOnExit();
+#else
// destroy GUI mutex
gs_mutexGui->Unlock();
delete gs_mutexGui;
+#endif
// and free TLD slot
(void)pthread_key_delete(gs_keySelf);
gs_nThreadsBeingDeleted++;
- wxLogTrace(TRACE_THREADS, _T("%lu thread%s waiting to be deleted"),
+ wxLogTrace(TRACE_THREADS, wxT("%lu thread%s waiting to be deleted"),
(unsigned long)gs_nThreadsBeingDeleted,
- gs_nThreadsBeingDeleted == 1 ? "" : "s");
+ gs_nThreadsBeingDeleted == 1 ? wxT("") : wxT("s"));
}
static void DeleteThread(wxThread *This)
{
- // gs_mutexDeleteThread should be unlocked before signalling the condition
- // or wxThreadModule::OnExit() would deadlock
- wxMutexLocker locker( *gs_mutexDeleteThread );
-
- wxLogTrace(TRACE_THREADS, _T("Thread %ld auto deletes."), This->GetId());
+ wxLogTrace(TRACE_THREADS, wxT("Thread %p auto deletes."), THR_ID(This));
delete This;
+ // only lock gs_mutexDeleteThread after deleting the thread to avoid
+ // calling out into user code with it locked as this may result in
+ // deadlocks if the thread dtor deletes another thread (see #11501)
+ wxMutexLocker locker( *gs_mutexDeleteThread );
+
wxCHECK_RET( gs_nThreadsBeingDeleted > 0,
- _T("no threads scheduled for deletion, yet we delete one?") );
+ wxT("no threads scheduled for deletion, yet we delete one?") );
- wxLogTrace(TRACE_THREADS, _T("%lu scheduled for deletion threads left."),
+ wxLogTrace(TRACE_THREADS, wxT("%lu threads remain scheduled for deletion."),
(unsigned long)gs_nThreadsBeingDeleted - 1);
if ( !--gs_nThreadsBeingDeleted )
}
}
-void wxMutexGuiEnter()
+#ifndef __WXOSX__
+
+void wxMutexGuiEnterImpl()
{
gs_mutexGui->Lock();
}
-void wxMutexGuiLeave()
+void wxMutexGuiLeaveImpl()
{
gs_mutexGui->Unlock();
}
+#endif
+
// ----------------------------------------------------------------------------
// include common implementation code
// ----------------------------------------------------------------------------
projects / wxWidgets.git / blobdiff