]> git.saurik.com Git - wxWidgets.git/blobdiff - src/unix/threadpsx.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Add missing WXK constants for the control keys
[wxWidgets.git] / src / unix / threadpsx.cpp
diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp
index 5895f57d77a28d799aa6d903b25c25a844ca5a75..de36955cda32ac2ce70ba3bb2b1fc2d0b36e5031 100644 (file)
--- a/src/unix/threadpsx.cpp
+++ b/src/unix/threadpsx.cpp
@@ -1,14 +1,15 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
-// Name:        threadpsx.cpp
+// Name:        src/unix/threadpsx.cpp
 // Purpose:     wxThread (Posix) Implementation
 // Author:      Original from Wolfram Gloger/Guilhem Lavaux
 // 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)
 // 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)
 //                  Robert Roebling (1999)
+//                  K. S. Sreeram (2002)
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
@@ -20,33 +21,52 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 
-#ifdef __GNUG__
-    #pragma implementation "thread.h"
-#endif
-
-// With simple makefiles, we must ignore the file body if not using
-// threads.
-#include "wx/setup.h"
+// for compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
 
 #if wxUSE_THREADS
 
 #include "wx/thread.h"
 
 #if wxUSE_THREADS
 
 #include "wx/thread.h"
-#include "wx/module.h"
-#include "wx/utils.h"
-#include "wx/log.h"
-#include "wx/intl.h"
-#include "wx/dynarray.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 "wx/utils.h"
+    #include "wx/timer.h"
+    #include "wx/stopwatch.h"
+    #include "wx/module.h"
+#endif
 
 #include <stdio.h>
 #include <unistd.h>
 #include <pthread.h>
 #include <errno.h>
 #include <time.h>
 
 #include <stdio.h>
 #include <unistd.h>
 #include <pthread.h>
 #include <errno.h>
 #include <time.h>
-
-#if HAVE_SCHED_H
+#include <sys/time.h>           // needed for at least __QNX__
+#ifdef HAVE_SCHED_H
     #include <sched.h>
 #endif
 
     #include <sched.h>
 #endif
 
+#ifdef HAVE_THR_SETCONCURRENCY
+    #include <thread.h>
+#endif
+
+#ifdef HAVE_ABI_FORCEDUNWIND
+    #include <cxxabi.h>
+#endif
+
+// we use wxFFile under Linux in GetCPUCount()
+#ifdef __LINUX__
+    #include "wx/ffile.h"
+    #include <sys/resource.h>   // for setpriority()
+#endif
+
+#define THR_ID_CAST(id)  (reinterpret_cast<void*>(id))
+#define THR_ID(thr)      THR_ID_CAST((thr)->GetId())
+
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
@@ -60,11 +80,30 @@ enum wxThreadState
     STATE_EXITED        // thread doesn't exist any more
 };
 
     STATE_EXITED        // thread doesn't exist any more
 };
 
+// the exit value of a thread which has been cancelled
+static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1;
+
+// trace mask for wxThread operations
+#define TRACE_THREADS   wxT("thread")
+
+// you can get additional debugging messages for the semaphore operations
+#define TRACE_SEMA      wxT("semaphore")
+
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
-// types
+// private functions
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 
-WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
+static void ScheduleThreadForDeletion();
+static void DeleteThread(wxThread *This);
+
+// ----------------------------------------------------------------------------
+// private classes
+// ----------------------------------------------------------------------------
+
+// an (non owning) array of pointers to threads
+WX_DEFINE_ARRAY_PTR(wxThread *, wxArrayThread);
+
+// an entry for a thread we can wait for
 
 // -----------------------------------------------------------------------------
 // global data
 
 // -----------------------------------------------------------------------------
 // global data
@@ -75,146 +114,588 @@ WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
 // be left in memory
 static wxArrayThread gs_allThreads;
 
 // be left in memory
 static wxArrayThread gs_allThreads;
 
+// a mutex to protect gs_allThreads
+static wxMutex *gs_mutexAllThreads = NULL;
+
 // the id of the main thread
 // the id of the main thread
-static pthread_t gs_tidMain;
+//
+// 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;
 
 
 // the key for the pointer to the associated wxThread object
 static pthread_key_t gs_keySelf;
 
+// the number of threads which are being deleted - the program won't exit
+// until there are any left
+static size_t gs_nThreadsBeingDeleted = 0;
+
+// a mutex to protect gs_nThreadsBeingDeleted
+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 = NULL;
+
+#ifndef __WXOSX__
 // this mutex must be acquired before any call to a GUI function
 // this mutex must be acquired before any call to a GUI function
-static wxMutex *gs_mutexGui;
+// (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
+// member of the thread itself as a detached thread may delete itself at any
+// moment and accessing the condition member of the thread after this would
+// result in a disaster
+//
+// so instead we maintain a global list of the structs below for the threads
+// we're interested in waiting on
 
 // ============================================================================
 
 // ============================================================================
-// implementation
+// wxMutex implementation
 // ============================================================================
 
 // ============================================================================
 
-//--------------------------------------------------------------------
-// wxMutex (Posix implementation)
-//--------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// wxMutexInternal
+// ----------------------------------------------------------------------------
 
 
+// this is a simple wrapper around pthread_mutex_t which provides error
+// checking
 class wxMutexInternal
 {
 public:
 class wxMutexInternal
 {
 public:
-    pthread_mutex_t p_mutex;
+    wxMutexInternal(wxMutexType mutexType);
+    ~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;
 };
 
 };
 
-wxMutex::wxMutex()
+#if defined(HAVE_PTHREAD_MUTEXATTR_T) && \
+        wxUSE_UNIX && !defined(HAVE_PTHREAD_MUTEXATTR_SETTYPE_DECL)
+// on some systems pthread_mutexattr_settype() is not in the headers (but it is
+// in the library, otherwise we wouldn't compile this code at all)
+extern "C" int pthread_mutexattr_settype(pthread_mutexattr_t *, int);
+#endif
+
+wxMutexInternal::wxMutexInternal(wxMutexType mutexType)
 {
 {
-    p_internal = new wxMutexInternal;
-    pthread_mutex_init( &(p_internal->p_mutex), (const pthread_mutexattr_t*) NULL );
-    m_locked = 0;
+    m_type = mutexType;
+    m_owningThread = 0;
+
+    int err;
+    switch ( mutexType )
+    {
+        case wxMUTEX_RECURSIVE:
+            // support recursive locks like Win32, i.e. a thread can lock a
+            // mutex which it had itself already locked
+            //
+            // unfortunately initialization of recursive mutexes is non
+            // portable, so try several methods
+#ifdef HAVE_PTHREAD_MUTEXATTR_T
+            {
+                pthread_mutexattr_t attr;
+                pthread_mutexattr_init(&attr);
+                pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+
+                err = 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_mutex = mutex;
+            }
+#else // no recursive mutexes
+            err = EINVAL;
+#endif // HAVE_PTHREAD_MUTEXATTR_T/...
+            break;
+
+        default:
+            wxFAIL_MSG( wxT("unknown mutex type") );
+            // fall through
+
+        case wxMUTEX_DEFAULT:
+            err = pthread_mutex_init(&m_mutex, NULL);
+            break;
+    }
+
+    m_isOk = err == 0;
+    if ( !m_isOk )
+    {
+        wxLogApiError( wxT("pthread_mutex_init()"), err);
+    }
 }
 
 }
 
-wxMutex::~wxMutex()
+wxMutexInternal::~wxMutexInternal()
 {
 {
-    if (m_locked > 0)
-        wxLogDebug("Freeing a locked mutex (%d locks)", m_locked);
+    if ( m_isOk )
+    {
+        int err = pthread_mutex_destroy(&m_mutex);
+        if ( err != 0 )
+        {
+            wxLogApiError( wxT("pthread_mutex_destroy()"), err);
+        }
+    }
+}
 
 
-    pthread_mutex_destroy( &(p_internal->p_mutex) );
-    delete p_internal;
+wxMutexError wxMutexInternal::Lock()
+{
+    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 wxMutex::Lock()
+wxMutexError wxMutexInternal::Lock(unsigned long ms)
 {
 {
-    int err = pthread_mutex_lock( &(p_internal->p_mutex) );
-    if (err == EDEADLK)
+#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 )
     {
     {
-        wxLogDebug("Locking this mutex would lead to deadlock!");
+    }
+#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);
+    }
 
 
-        return wxMUTEX_DEAD_LOCK;
+    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;
     }
 
     }
 
-    m_locked++;
+    return HandleLockResult(pthread_mutex_timedlock(&m_mutex, &ts));
+#else // !HAVE_PTHREAD_MUTEX_TIMEDLOCK
+    wxUnusedVar(ms);
 
 
-    return wxMUTEX_NO_ERROR;
+    return wxMUTEX_MISC_ERROR;
+#endif // HAVE_PTHREAD_MUTEX_TIMEDLOCK/!HAVE_PTHREAD_MUTEX_TIMEDLOCK
 }
 
 }
 
-wxMutexError wxMutex::TryLock()
+wxMutexError wxMutexInternal::HandleLockResult(int err)
 {
 {
-    if (m_locked)
+    // wxPrintf( "err %d\n", err );
+
+    switch ( err )
     {
     {
-        return wxMUTEX_BUSY;
+        case EDEADLK:
+            // only error checking mutexes return this value and so it's an
+            // unexpected situation -- hence use assert, not wxLogDebug
+            wxFAIL_MSG( wxT("mutex deadlock prevented") );
+            return wxMUTEX_DEAD_LOCK;
+
+        case EINVAL:
+            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(wxT("pthread_mutex_[timed]lock()"), err);
     }
 
     }
 
-    int err = pthread_mutex_trylock( &(p_internal->p_mutex) );
-    switch (err)
+    return wxMUTEX_MISC_ERROR;
+}
+
+
+wxMutexError wxMutexInternal::TryLock()
+{
+    int err = pthread_mutex_trylock(&m_mutex);
+    switch ( err )
     {
     {
-        case EBUSY: return wxMUTEX_BUSY;
+        case EBUSY:
+            // not an error: mutex is already locked, but we're prepared for
+            // this
+            return wxMUTEX_BUSY;
+
+        case EINVAL:
+            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(wxT("pthread_mutex_trylock()"), err);
     }
 
     }
 
-    m_locked++;
+    return wxMUTEX_MISC_ERROR;
+}
+
+wxMutexError wxMutexInternal::Unlock()
+{
+    m_owningThread = 0;
 
 
-    return wxMUTEX_NO_ERROR;
+    int err = pthread_mutex_unlock(&m_mutex);
+    switch ( err )
+    {
+        case EPERM:
+            // we don't own the mutex
+            return wxMUTEX_UNLOCKED;
+
+        case EINVAL:
+            wxLogDebug(wxT("pthread_mutex_unlock(): mutex not initialized."));
+            break;
+
+        case 0:
+            return wxMUTEX_NO_ERROR;
+
+        default:
+            wxLogApiError(wxT("pthread_mutex_unlock()"), err);
+    }
+
+    return wxMUTEX_MISC_ERROR;
 }
 
 }
 
-wxMutexError wxMutex::Unlock()
+// ===========================================================================
+// wxCondition implementation
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// wxConditionInternal
+// ---------------------------------------------------------------------------
+
+// this is a wrapper around pthread_cond_t associated with a wxMutex (and hence
+// with a pthread_mutex_t)
+class wxConditionInternal
+{
+public:
+    wxConditionInternal(wxMutex& mutex);
+    ~wxConditionInternal();
+
+    bool IsOk() const { return m_isOk && m_mutex.IsOk(); }
+
+    wxCondError Wait();
+    wxCondError WaitTimeout(unsigned long milliseconds);
+
+    wxCondError Signal();
+    wxCondError Broadcast();
+
+private:
+    // get the POSIX mutex associated with us
+    pthread_mutex_t *GetPMutex() const { return &m_mutex.m_internal->m_mutex; }
+
+    wxMutex& m_mutex;
+    pthread_cond_t m_cond;
+
+    bool m_isOk;
+};
+
+wxConditionInternal::wxConditionInternal(wxMutex& mutex)
+                   : m_mutex(mutex)
 {
 {
-    if (m_locked > 0)
+    int err = pthread_cond_init(&m_cond, NULL /* default attributes */);
+
+    m_isOk = err == 0;
+
+    if ( !m_isOk )
     {
     {
-        m_locked--;
+        wxLogApiError(wxT("pthread_cond_init()"), err);
     }
     }
-    else
+}
+
+wxConditionInternal::~wxConditionInternal()
+{
+    if ( m_isOk )
     {
     {
-        wxLogDebug("Unlocking not locked mutex.");
+        int err = pthread_cond_destroy(&m_cond);
+        if ( err != 0 )
+        {
+            wxLogApiError(wxT("pthread_cond_destroy()"), err);
+        }
+    }
+}
+
+wxCondError wxConditionInternal::Wait()
+{
+    int err = pthread_cond_wait(&m_cond, GetPMutex());
+    if ( err != 0 )
+    {
+        wxLogApiError(wxT("pthread_cond_wait()"), err);
 
 
-        return wxMUTEX_UNLOCKED;
+        return wxCOND_MISC_ERROR;
     }
 
     }
 
-    pthread_mutex_unlock( &(p_internal->p_mutex) );
+    return wxCOND_NO_ERROR;
+}
+
+wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds)
+{
+    wxLongLong curtime = wxGetUTCTimeMillis();
+    curtime += milliseconds;
+    wxLongLong temp = curtime / 1000;
+    int sec = temp.GetLo();
+    temp *= 1000;
+    temp = curtime - temp;
+    int millis = temp.GetLo();
 
 
-    return wxMUTEX_NO_ERROR;
+    timespec tspec;
+
+    tspec.tv_sec = sec;
+    tspec.tv_nsec = millis * 1000L * 1000L;
+
+    int err = pthread_cond_timedwait( &m_cond, GetPMutex(), &tspec );
+    switch ( err )
+    {
+        case ETIMEDOUT:
+            return wxCOND_TIMEOUT;
+
+        case 0:
+            return wxCOND_NO_ERROR;
+
+        default:
+            wxLogApiError(wxT("pthread_cond_timedwait()"), err);
+    }
+
+    return wxCOND_MISC_ERROR;
 }
 
 }
 
-//--------------------------------------------------------------------
-// wxCondition (Posix implementation)
-//--------------------------------------------------------------------
+wxCondError wxConditionInternal::Signal()
+{
+    int err = pthread_cond_signal(&m_cond);
+    if ( err != 0 )
+    {
+        wxLogApiError(wxT("pthread_cond_signal()"), err);
 
 
-class wxConditionInternal
+        return wxCOND_MISC_ERROR;
+    }
+
+    return wxCOND_NO_ERROR;
+}
+
+wxCondError wxConditionInternal::Broadcast()
+{
+    int err = pthread_cond_broadcast(&m_cond);
+    if ( err != 0 )
+    {
+        wxLogApiError(wxT("pthread_cond_broadcast()"), err);
+
+        return wxCOND_MISC_ERROR;
+    }
+
+    return wxCOND_NO_ERROR;
+}
+
+// ===========================================================================
+// wxSemaphore implementation
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// wxSemaphoreInternal
+// ---------------------------------------------------------------------------
+
+// we implement the semaphores using mutexes and conditions instead of using
+// the sem_xxx() POSIX functions because they're not widely available and also
+// because it's impossible to implement WaitTimeout() using them
+class wxSemaphoreInternal
 {
 public:
 {
 public:
-  pthread_cond_t p_condition;
+    wxSemaphoreInternal(int initialcount, int maxcount);
+
+    bool IsOk() const { return m_isOk; }
+
+    wxSemaError Wait();
+    wxSemaError TryWait();
+    wxSemaError WaitTimeout(unsigned long milliseconds);
+
+    wxSemaError Post();
+
+private:
+    wxMutex m_mutex;
+    wxCondition m_cond;
+
+    size_t m_count,
+           m_maxcount;
+
+    bool m_isOk;
 };
 
 };
 
-wxCondition::wxCondition()
+wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
+                   : m_cond(m_mutex)
 {
 {
-    p_internal = new wxConditionInternal;
-    pthread_cond_init( &(p_internal->p_condition), (const pthread_condattr_t *) NULL );
+
+    if ( (initialcount < 0 || maxcount < 0) ||
+            ((maxcount > 0) && (initialcount > maxcount)) )
+    {
+        wxFAIL_MSG( wxT("wxSemaphore: invalid initial or maximal count") );
+
+        m_isOk = false;
+    }
+    else
+    {
+        m_maxcount = (size_t)maxcount;
+        m_count = (size_t)initialcount;
+    }
+
+    m_isOk = m_mutex.IsOk() && m_cond.IsOk();
 }
 
 }
 
-wxCondition::~wxCondition()
+wxSemaError wxSemaphoreInternal::Wait()
 {
 {
-    pthread_cond_destroy( &(p_internal->p_condition) );
+    wxMutexLocker locker(m_mutex);
 
 
-    delete p_internal;
+    while ( m_count == 0 )
+    {
+        wxLogTrace(TRACE_SEMA,
+                   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,
+                   wxT("Thread %p finished waiting for semaphore, count = %lu"),
+                   THR_ID_CAST(wxThread::GetCurrentId()), (unsigned long)m_count);
+    }
+
+    m_count--;
+
+    return wxSEMA_NO_ERROR;
 }
 
 }
 
-void wxCondition::Wait(wxMutex& mutex)
+wxSemaError wxSemaphoreInternal::TryWait()
 {
 {
-    pthread_cond_wait( &(p_internal->p_condition), &(mutex.p_internal->p_mutex) );
+    wxMutexLocker locker(m_mutex);
+
+    if ( m_count == 0 )
+        return wxSEMA_BUSY;
+
+    m_count--;
+
+    return wxSEMA_NO_ERROR;
 }
 
 }
 
-bool wxCondition::Wait(wxMutex& mutex, unsigned long sec, unsigned long nsec)
+wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds)
 {
 {
-    struct timespec tspec;
+    wxMutexLocker locker(m_mutex);
+
+    wxLongLong startTime = wxGetLocalTimeMillis();
+
+    while ( m_count == 0 )
+    {
+        wxLongLong elapsed = wxGetLocalTimeMillis() - startTime;
+        long remainingTime = (long)milliseconds - (long)elapsed.GetLo();
+        if ( remainingTime <= 0 )
+        {
+            // timeout
+            return wxSEMA_TIMEOUT;
+        }
+
+        switch ( m_cond.WaitTimeout(remainingTime) )
+        {
+            case wxCOND_TIMEOUT:
+                return wxSEMA_TIMEOUT;
+
+            default:
+                return wxSEMA_MISC_ERROR;
+
+            case wxCOND_NO_ERROR:
+                ;
+        }
+    }
 
 
-    tspec.tv_sec = time(0L)+sec;
-    tspec.tv_nsec = nsec;
-    return (pthread_cond_timedwait(&(p_internal->p_condition), &(mutex.p_internal->p_mutex), &tspec) != ETIMEDOUT);
+    m_count--;
+
+    return wxSEMA_NO_ERROR;
 }
 
 }
 
-void wxCondition::Signal()
+wxSemaError wxSemaphoreInternal::Post()
 {
 {
-    pthread_cond_signal( &(p_internal->p_condition) );
+    wxMutexLocker locker(m_mutex);
+
+    if ( m_maxcount > 0 && m_count == m_maxcount )
+    {
+        return wxSEMA_OVERFLOW;
+    }
+
+    m_count++;
+
+    wxLogTrace(TRACE_SEMA,
+               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;
 }
 
 }
 
-void wxCondition::Broadcast()
+// ===========================================================================
+// wxThread implementation
+// ===========================================================================
+
+// the thread callback functions must have the C linkage
+extern "C"
 {
 {
-    pthread_cond_broadcast( &(p_internal->p_condition) );
-}
 
 
-//--------------------------------------------------------------------
-// wxThread (Posix implementation)
-//--------------------------------------------------------------------
+#ifdef wxHAVE_PTHREAD_CLEANUP
+    // thread exit function
+    void wxPthreadCleanup(void *ptr);
+#endif // wxHAVE_PTHREAD_CLEANUP
+
+void *wxPthreadStart(void *ptr);
+
+} // extern "C"
+
+// ----------------------------------------------------------------------------
+// wxThreadInternal
+// ----------------------------------------------------------------------------
 
 class wxThreadInternal
 {
 
 class wxThreadInternal
 {
@@ -223,15 +704,15 @@ public:
     ~wxThreadInternal();
 
     // thread entry function
     ~wxThreadInternal();
 
     // thread entry function
-    static void *PthreadStart(void *ptr);
+    static void *PthreadStart(wxThread *thread);
 
     // thread actions
         // start the thread
     wxThreadError Run();
 
     // thread actions
         // start the thread
     wxThreadError Run();
+        // unblock the thread allowing it to run
+    void SignalRun() { m_semRun.Post(); }
         // ask the thread to terminate
     void Wait();
         // ask the thread to terminate
     void Wait();
-        // wake up threads waiting for our termination
-    void SignalExit();
         // go to sleep until Resume() is called
     void Pause();
         // resume the thread
         // go to sleep until Resume() is called
     void Pause();
         // resume the thread
@@ -243,147 +724,317 @@ public:
     void SetPriority(int prio) { m_prio = prio; }
         // state
     wxThreadState GetState() const { return m_state; }
     void SetPriority(int prio) { m_prio = prio; }
         // state
     wxThreadState GetState() const { return m_state; }
-    void SetState(wxThreadState state) { m_state = state; }
+    void SetState(wxThreadState state)
+    {
+#if wxUSE_LOG_TRACE
+        static const wxChar *const stateNames[] =
+        {
+            wxT("NEW"),
+            wxT("RUNNING"),
+            wxT("PAUSED"),
+            wxT("EXITED"),
+        };
+
+        wxLogTrace(TRACE_THREADS, wxT("Thread %p: %s => %s."),
+                   THR_ID(this), stateNames[m_state], stateNames[state]);
+#endif // wxUSE_LOG_TRACE
+
+        m_state = state;
+    }
         // id
     pthread_t GetId() const { return m_threadId; }
     pthread_t *GetIdPtr() { return &m_threadId; }
         // "cancelled" flag
         // id
     pthread_t GetId() const { return m_threadId; }
     pthread_t *GetIdPtr() { return &m_threadId; }
         // "cancelled" flag
-    void SetCancelFlag() { m_cancelled = TRUE; }
+    void SetCancelFlag() { m_cancelled = true; }
     bool WasCancelled() const { return m_cancelled; }
     bool WasCancelled() const { return m_cancelled; }
+        // exit code
+    void SetExitCode(wxThread::ExitCode exitcode) { m_exitcode = exitcode; }
+    wxThread::ExitCode GetExitCode() const { return m_exitcode; }
+
+        // the pause flag
+    void SetReallyPaused(bool paused) { m_isPaused = paused; }
+    bool IsReallyPaused() const { return m_isPaused; }
+
+        // tell the thread that it is a detached one
+    void Detach()
+    {
+        wxCriticalSectionLocker lock(m_csJoinFlag);
+
+        m_shouldBeJoined = false;
+        m_isDetached = true;
+    }
+
+#ifdef wxHAVE_PTHREAD_CLEANUP
+    // this is used by wxPthreadCleanup() only
+    static void Cleanup(wxThread *thread);
+#endif // wxHAVE_PTHREAD_CLEANUP
 
 private:
     pthread_t     m_threadId;   // id of the thread
     wxThreadState m_state;      // see wxThreadState enum
 
 private:
     pthread_t     m_threadId;   // id of the thread
     wxThreadState m_state;      // see wxThreadState enum
-    int           m_prio;       // in wxWindows units: from 0 to 100
+    int           m_prio;       // in wxWidgets units: from 0 to 100
 
 
-    // set when the thread should terminate
+    // this flag is set when the thread should terminate
     bool m_cancelled;
 
     bool m_cancelled;
 
-    // this (mutex, cond) pair is used to synchronize the main thread and this
-    // thread in several situations:
-    //  1. The thread function blocks until condition is signaled by Run() when
-    //     it's initially created - this allows thread creation in "suspended"
-    //     state
-    //  2. The Delete() function blocks until the condition is signaled when the
-    //     thread exits.
-    wxMutex     m_mutex;
-    wxCondition m_cond;
+    // 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
+    // is only valid after the thread termination
+    wxThread::ExitCode m_exitcode;
+
+    // many threads may call Wait(), but only one of them should call
+    // pthread_join(), so we have to keep track of this
+    wxCriticalSection m_csJoinFlag;
+    bool m_shouldBeJoined;
+    bool m_isDetached;
 
 
-    // another (mutex, cond) pair for Pause()/Resume() usage
-    //
-    // VZ: it's possible that we might reuse the mutex and condition from above
-    //     for this too, but as I'm not at all sure that it won't create subtle
-    //     problems with race conditions between, say, Pause() and Delete() I
-    //     prefer this may be a bit less efficient but much safer solution
-    wxMutex     m_mutexSuspend;
-    wxCondition m_condSuspend;
+    // this semaphore is posted by Run() and the threads Entry() is not
+    // called before it is done
+    wxSemaphore m_semRun;
+
+    // this one is signaled when the thread should resume after having been
+    // Pause()d
+    wxSemaphore m_semSuspend;
 };
 
 };
 
-void *wxThreadInternal::PthreadStart(void *ptr)
+// ----------------------------------------------------------------------------
+// thread startup and exit functions
+// ----------------------------------------------------------------------------
+
+void *wxPthreadStart(void *ptr)
+{
+    return wxThreadInternal::PthreadStart((wxThread *)ptr);
+}
+
+void *wxThreadInternal::PthreadStart(wxThread *thread)
 {
 {
-    wxThread *thread = (wxThread *)ptr;
-    wxThreadInternal *pthread = thread->p_internal;
+    wxThreadInternal *pthread = thread->m_internal;
 
 
+    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
     int rc = pthread_setspecific(gs_keySelf, thread);
     if ( rc != 0 )
     {
     int rc = pthread_setspecific(gs_keySelf, thread);
     if ( rc != 0 )
     {
-        wxLogSysError(rc, _("Can not start thread: error writing TLS."));
+        wxLogSysError(rc, _("Cannot start thread: error writing TLS."));
 
         return (void *)-1;
     }
 
 
         return (void *)-1;
     }
 
-    // wait for the condition to be signaled from Run()
-    // mutex state: currently locked by the thread which created us
-    pthread->m_cond.Wait(pthread->m_mutex);
+    // have to declare this before pthread_cleanup_push() which defines a
+    // block!
+    bool dontRunAtAll;
+
+#ifdef wxHAVE_PTHREAD_CLEANUP
+    // install the cleanup handler which will be called if the thread is
+    // cancelled
+    pthread_cleanup_push(wxPthreadCleanup, thread);
+#endif // wxHAVE_PTHREAD_CLEANUP
+
+    // 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()?
+    {
+        wxCriticalSectionLocker lock(thread->m_critsect);
+
+        dontRunAtAll = pthread->GetState() == STATE_NEW &&
+                       pthread->WasCancelled();
+    }
+
+    if ( !dontRunAtAll )
+    {
+        // call the main entry
+        wxLogTrace(TRACE_THREADS,
+                   wxT("Thread %p about to enter its Entry()."),
+                   THR_ID(pthread));
+
+        wxTRY
+        {
+            pthread->m_exitcode = thread->Entry();
+
+            wxLogTrace(TRACE_THREADS,
+                       wxT("Thread %p Entry() returned %lu."),
+                       THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode));
+        }
+#ifdef HAVE_ABI_FORCEDUNWIND
+        // When using common C++ ABI under Linux we must always rethrow this
+        // special exception used to unwind the stack when the thread was
+        // cancelled, otherwise the thread library would simply terminate the
+        // program, see http://udrepper.livejournal.com/21541.html
+        catch ( abi::__forced_unwind& )
+        {
+            wxCriticalSectionLocker lock(thread->m_critsect);
+            pthread->SetState(STATE_EXITED);
+            throw;
+        }
+#endif // HAVE_ABI_FORCEDUNWIND
+        wxCATCH_ALL( wxTheApp->OnUnhandledException(); )
+
+        {
+            wxCriticalSectionLocker lock(thread->m_critsect);
+
+            // change the state of the thread to "exited" so that
+            // wxPthreadCleanup handler won't do anything from now (if it's
+            // called before we do pthread_cleanup_pop below)
+            pthread->SetState(STATE_EXITED);
+        }
+    }
+
+    // NB: pthread_cleanup_push/pop() are macros and pop contains the matching
+    //     '}' for the '{' in push, so they must be used in the same block!
+#ifdef wxHAVE_PTHREAD_CLEANUP
+    #ifdef __DECCXX
+        // under Tru64 we get a warning from macro expansion
+        #pragma message save
+        #pragma message disable(declbutnotref)
+    #endif
+
+    // remove the cleanup handler without executing it
+    pthread_cleanup_pop(FALSE);
+
+    #ifdef __DECCXX
+        #pragma message restore
+    #endif
+#endif // wxHAVE_PTHREAD_CLEANUP
+
+    if ( dontRunAtAll )
+    {
+        // FIXME: deleting a possibly joinable thread here???
+        delete thread;
+
+        return EXITCODE_CANCELLED;
+    }
+    else
+    {
+        // terminate the thread
+        thread->Exit(pthread->m_exitcode);
+
+        wxFAIL_MSG(wxT("wxThread::Exit() can't return."));
 
 
-    // mutex state: locked again on exit of Wait()
+        return NULL;
+    }
+}
 
 
-    // call the main entry
-    void* status = thread->Entry();
+#ifdef wxHAVE_PTHREAD_CLEANUP
 
 
-    // terminate the thread
-    thread->Exit(status);
+// this handler is called when the thread is cancelled
+extern "C" void wxPthreadCleanup(void *ptr)
+{
+    wxThreadInternal::Cleanup((wxThread *)ptr);
+}
 
 
-    wxFAIL_MSG("wxThread::Exit() can't return.");
+void wxThreadInternal::Cleanup(wxThread *thread)
+{
+    if (pthread_getspecific(gs_keySelf) == 0) return;
+    {
+        wxCriticalSectionLocker lock(thread->m_critsect);
+        if ( thread->m_internal->GetState() == STATE_EXITED )
+        {
+            // thread is already considered as finished.
+            return;
+        }
+    }
 
 
-    return NULL;
+    // exit the thread gracefully
+    thread->Exit(EXITCODE_CANCELLED);
 }
 
 }
 
+#endif // wxHAVE_PTHREAD_CLEANUP
+
+// ----------------------------------------------------------------------------
+// wxThreadInternal
+// ----------------------------------------------------------------------------
+
 wxThreadInternal::wxThreadInternal()
 {
     m_state = STATE_NEW;
 wxThreadInternal::wxThreadInternal()
 {
     m_state = STATE_NEW;
-    m_cancelled = FALSE;
+    m_cancelled = false;
+    m_prio = WXTHREAD_DEFAULT_PRIORITY;
+    m_threadId = 0;
+    m_exitcode = 0;
 
 
-    // this mutex is locked during almost all thread lifetime - it will only be
-    // unlocked in the very end
-    m_mutex.Lock();
+    // set to true only when the thread starts waiting on m_semSuspend
+    m_isPaused = false;
 
 
-    // this mutex is used in Pause()/Resume() and is also locked all the time
-    // unless the thread is paused
-    m_mutexSuspend.Lock();
+    // defaults for joinable threads
+    m_shouldBeJoined = true;
+    m_isDetached = false;
 }
 
 wxThreadInternal::~wxThreadInternal()
 {
 }
 
 wxThreadInternal::~wxThreadInternal()
 {
-    m_mutexSuspend.Unlock();
-
-    // note that m_mutex will be unlocked by the thread which waits for our
-    // termination
 }
 
 wxThreadError wxThreadInternal::Run()
 {
     wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
 }
 
 wxThreadError wxThreadInternal::Run()
 {
     wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
-                 "thread may only be started once after successful Create()" );
+                 wxT("thread may only be started once after Create()") );
 
 
-    // the mutex was locked on Create(), so we will be able to lock it again
-    // only when the thread really starts executing and enters the wait -
-    // otherwise we might signal the condition before anybody is waiting for it
-    wxMutexLocker lock(m_mutex);
-    m_cond.Signal();
+    SetState(STATE_RUNNING);
 
 
-    m_state = STATE_RUNNING;
+    // wake up threads waiting for our start
+    SignalRun();
 
     return wxTHREAD_NO_ERROR;
 
     return wxTHREAD_NO_ERROR;
-
-    // now the mutex is unlocked back - but just to allow Wait() function to
-    // terminate by relocking it, so the net result is that the worker thread
-    // starts executing and the mutex is still locked
 }
 
 void wxThreadInternal::Wait()
 {
 }
 
 void wxThreadInternal::Wait()
 {
-    wxCHECK_RET( WasCancelled(), "thread should have been cancelled first" );
+    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() )
 
     // 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();
         wxMutexGuiLeave();
+#endif
+    }
+
+    wxLogTrace(TRACE_THREADS,
+               wxT("Starting to wait for thread %p to exit."),
+               THR_ID(this));
 
 
-    // entering Wait() releases the mutex thus allowing SignalExit() to acquire
-    // it and to signal us its termination
-    m_cond.Wait(m_mutex);
+    // to avoid memory leaks we should call pthread_join(), but it must only be
+    // done once so use a critical section to serialize the code below
+    {
+        wxCriticalSectionLocker lock(m_csJoinFlag);
+
+        if ( m_shouldBeJoined )
+        {
+            // FIXME shouldn't we set cancellation type to DISABLED here? If
+            //       we're cancelled inside pthread_join(), things will almost
+            //       certainly break - but if we disable the cancellation, we
+            //       might deadlock
+            if ( pthread_join(GetId(), &m_exitcode) != 0 )
+            {
+                // this is a serious problem, so use wxLogError and not
+                // wxLogDebug: it is possible to bring the system to its knees
+                // by creating too many threads and not joining them quite
+                // easily
+                wxLogError(_("Failed to join a thread, potential memory leak detected - please restart the program"));
+            }
 
 
-    // mutex is still in the locked state - relocked on exit from Wait(), so
-    // unlock it - we don't need it any more, the thread has already terminated
-    m_mutex.Unlock();
+            m_shouldBeJoined = false;
+        }
+    }
 
 
+#ifndef __WXOSX__
     // reacquire GUI mutex
     if ( wxThread::IsMain() )
         wxMutexGuiEnter();
     // reacquire GUI mutex
     if ( wxThread::IsMain() )
         wxMutexGuiEnter();
-}
-
-void wxThreadInternal::SignalExit()
-{
-    // as mutex is currently locked, this will block until some other thread
-    // (normally the same which created this one) unlocks it by entering Wait()
-    m_mutex.Lock();
-
-    // wake up all the threads waiting for our termination
-    m_cond.Broadcast();
-
-    // after this call mutex will be finally unlocked
-    m_mutex.Unlock();
+#endif
 }
 
 void wxThreadInternal::Pause()
 }
 
 void wxThreadInternal::Pause()
@@ -391,32 +1042,44 @@ void wxThreadInternal::Pause()
     // the state is set from the thread which pauses us first, this function
     // is called later so the state should have been already set
     wxCHECK_RET( m_state == STATE_PAUSED,
     // the state is set from the thread which pauses us first, this function
     // is called later so the state should have been already set
     wxCHECK_RET( m_state == STATE_PAUSED,
-                 "thread must first be paused with wxThread::Pause()." );
+                 wxT("thread must first be paused with wxThread::Pause().") );
 
 
-    // don't pause the thread which is being terminated - this would lead to
-    // deadlock if the thread is paused after Delete() had called Resume() but
-    // before it had time to call Wait()
-    if ( WasCancelled() )
-        return;
+   wxLogTrace(TRACE_THREADS,
+              wxT("Thread %p goes to sleep."), THR_ID(this));
 
 
-    // wait until the condition is signaled from Resume()
-    m_condSuspend.Wait(m_mutexSuspend);
+    // wait until the semaphore is Post()ed from Resume()
+    m_semSuspend.Wait();
 }
 
 void wxThreadInternal::Resume()
 {
     wxCHECK_RET( m_state == STATE_PAUSED,
 }
 
 void wxThreadInternal::Resume()
 {
     wxCHECK_RET( m_state == STATE_PAUSED,
-                 "can't resume thread which is not suspended." );
+                 wxT("can't resume thread which is not suspended.") );
+
+    // the thread might be not actually paused yet - if there were no call to
+    // TestDestroy() since the last call to Pause() for example
+    if ( IsReallyPaused() )
+    {
+       wxLogTrace(TRACE_THREADS,
+                  wxT("Waking up thread %p"), THR_ID(this));
 
 
-    // we will be able to lock this mutex only when Pause() starts waiting
-    wxMutexLocker lock(m_mutexSuspend);
-    m_condSuspend.Signal();
+        // wake up Pause()
+        m_semSuspend.Post();
+
+        // reset the flag
+        SetReallyPaused(false);
+    }
+    else
+    {
+        wxLogTrace(TRACE_THREADS,
+                   wxT("Thread %p is not yet really paused"), THR_ID(this));
+    }
 
     SetState(STATE_RUNNING);
 }
 
 // -----------------------------------------------------------------------------
 
     SetState(STATE_RUNNING);
 }
 
 // -----------------------------------------------------------------------------
-// static functions
+// wxThread static functions
 // -----------------------------------------------------------------------------
 
 wxThread *wxThread::This()
 // -----------------------------------------------------------------------------
 
 wxThread *wxThread::This()
@@ -424,75 +1087,217 @@ wxThread *wxThread::This()
     return (wxThread *)pthread_getspecific(gs_keySelf);
 }
 
     return (wxThread *)pthread_getspecific(gs_keySelf);
 }
 
-bool wxThread::IsMain()
+void wxThread::Yield()
 {
 {
-    return (bool)pthread_equal(pthread_self(), gs_tidMain);
+#ifdef HAVE_SCHED_YIELD
+    sched_yield();
+#endif
 }
 
 }
 
-void wxThread::Yield()
+int wxThread::GetCPUCount()
 {
 {
-    sched_yield();
+#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(wxT("/proc/cpuinfo"));
+    if ( file.IsOpened() )
+    {
+        // slurp the whole file
+        wxString s;
+        if ( file.ReadAll(&s) )
+        {
+            // (ab)use Replace() to find the number of "processor: num" strings
+            size_t count = s.Replace(wxT("processor\t:"), wxT(""));
+            if ( count > 0 )
+            {
+                return count;
+            }
+
+            wxLogDebug(wxT("failed to parse /proc/cpuinfo"));
+        }
+        else
+        {
+            wxLogDebug(wxT("failed to read /proc/cpuinfo"));
+        }
+    }
+#endif // different ways to get number of CPUs
+
+    // unknown
+    return -1;
 }
 
 }
 
-void wxThread::Sleep(unsigned long milliseconds)
+wxThreadIdType wxThread::GetCurrentId()
 {
 {
-    wxUsleep(milliseconds);
+    return (wxThreadIdType)pthread_self();
+}
+
+
+bool wxThread::SetConcurrency(size_t level)
+{
+#ifdef HAVE_PTHREAD_SET_CONCURRENCY
+    int rc = pthread_setconcurrency( level );
+#elif defined(HAVE_THR_SETCONCURRENCY)
+    int rc = thr_setconcurrency(level);
+#else // !HAVE_THR_SETCONCURRENCY
+    // ok only for the default value
+    int rc = level == 0 ? 0 : -1;
+#endif // HAVE_THR_SETCONCURRENCY/!HAVE_THR_SETCONCURRENCY
+
+    if ( rc != 0 )
+    {
+        wxLogSysError(rc, _("Failed to set thread concurrency level to %lu"),
+                      static_cast<unsigned long>(level));
+        return false;
+    }
+
+    return true;
 }
 
 // -----------------------------------------------------------------------------
 // creating thread
 // -----------------------------------------------------------------------------
 
 }
 
 // -----------------------------------------------------------------------------
 // creating thread
 // -----------------------------------------------------------------------------
 
-wxThread::wxThread()
+wxThread::wxThread(wxThreadKind kind)
 {
     // add this thread to the global list of all threads
 {
     // add this thread to the global list of all threads
-    gs_allThreads.Add(this);
+    {
+        wxMutexLocker lock(*gs_mutexAllThreads);
 
 
-    p_internal = new wxThreadInternal();
+        gs_allThreads.Add(this);
+    }
+
+    m_internal = new wxThreadInternal();
+
+    m_isDetached = kind == wxTHREAD_DETACHED;
 }
 
 }
 
-wxThreadError wxThread::Create()
+#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
+    #define WXUNUSED_STACKSIZE(identifier)  identifier
+#else
+    #define WXUNUSED_STACKSIZE(identifier)  WXUNUSED(identifier)
+#endif
+
+wxThreadError wxThread::Create(unsigned int WXUNUSED_STACKSIZE(stackSize))
 {
 {
-    if (p_internal->GetState() != STATE_NEW)
+    if ( m_internal->GetState() != STATE_NEW )
+    {
+        // don't recreate thread
         return wxTHREAD_RUNNING;
         return wxTHREAD_RUNNING;
+    }
 
     // set up the thread attribute: right now, we only set thread priority
     pthread_attr_t attr;
     pthread_attr_init(&attr);
 
 
     // set up the thread attribute: right now, we only set thread priority
     pthread_attr_t attr;
     pthread_attr_init(&attr);
 
+#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
+    if (stackSize)
+      pthread_attr_setstacksize(&attr, stackSize);
+#endif
+
 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
-    int prio;
-    if ( pthread_attr_getschedpolicy(&attr, &prio) != 0 )
+    int policy;
+    if ( pthread_attr_getschedpolicy(&attr, &policy) != 0 )
     {
     {
-        wxLogError(_("Can not retrieve thread scheduling policy."));
+        wxLogError(_("Cannot retrieve thread scheduling policy."));
     }
 
     }
 
-    int min_prio = sched_get_priority_min(prio),
-        max_prio = sched_get_priority_max(prio);
+#ifdef __VMS__
+   /* the pthread.h contains too many spaces. This is a work-around */
+# undef sched_get_priority_max
+#undef sched_get_priority_min
+#define sched_get_priority_max(_pol_) \
+     (_pol_ == SCHED_OTHER ? PRI_FG_MAX_NP : PRI_FIFO_MAX)
+#define sched_get_priority_min(_pol_) \
+     (_pol_ == SCHED_OTHER ? PRI_FG_MIN_NP : PRI_FIFO_MIN)
+#endif
+
+    int max_prio = sched_get_priority_max(policy),
+        min_prio = sched_get_priority_min(policy),
+        prio = m_internal->GetPriority();
 
     if ( min_prio == -1 || max_prio == -1 )
     {
 
     if ( min_prio == -1 || max_prio == -1 )
     {
-        wxLogError(_("Can not get priority range for scheduling policy %d."),
-                   prio);
+        wxLogError(_("Cannot get priority range for scheduling policy %d."),
+                   policy);
+    }
+    else if ( max_prio == min_prio )
+    {
+        if ( prio != WXTHREAD_DEFAULT_PRIORITY )
+        {
+            // notify the programmer that this doesn't work here
+            wxLogWarning(_("Thread priority setting is ignored."));
+        }
+        //else: we have default priority, so don't complain
+
+        // anyhow, don't do anything because priority is just ignored
     }
     else
     {
         struct sched_param sp;
     }
     else
     {
         struct sched_param sp;
-        pthread_attr_getschedparam(&attr, &sp);
-        sp.sched_priority = min_prio +
-                           (p_internal->GetPriority()*(max_prio-min_prio))/100;
-        pthread_attr_setschedparam(&attr, &sp);
+        if ( pthread_attr_getschedparam(&attr, &sp) != 0 )
+        {
+            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(wxT("pthread_attr_setschedparam(priority) failed"));
+        }
     }
 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS
 
     }
 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS
 
+#ifdef HAVE_PTHREAD_ATTR_SETSCOPE
+    // this will make the threads created by this process really concurrent
+    if ( pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) != 0 )
+    {
+        wxFAIL_MSG(wxT("pthread_attr_setscope(PTHREAD_SCOPE_SYSTEM) failed"));
+    }
+#endif // HAVE_PTHREAD_ATTR_SETSCOPE
+
+    // VZ: assume that this one is always available (it's rather fundamental),
+    //     if this function is ever missing we should try to use
+    //     pthread_detach() instead (after thread creation)
+    if ( m_isDetached )
+    {
+        if ( pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0 )
+        {
+            wxFAIL_MSG(wxT("pthread_attr_setdetachstate(DETACHED) failed"));
+        }
+
+        // never try to join detached threads
+        m_internal->Detach();
+    }
+    //else: threads are created joinable by default, it's ok
+
     // create the new OS thread object
     // create the new OS thread object
-    int rc = pthread_create(p_internal->GetIdPtr(), &attr,
-                            wxThreadInternal::PthreadStart, (void *)this);
-    pthread_attr_destroy(&attr);
+    int rc = pthread_create
+             (
+                m_internal->GetIdPtr(),
+                &attr,
+                wxPthreadStart,
+                (void *)this
+             );
+
+    if ( pthread_attr_destroy(&attr) != 0 )
+    {
+        wxFAIL_MSG(wxT("pthread_attr_destroy() failed"));
+    }
 
     if ( rc != 0 )
     {
 
     if ( rc != 0 )
     {
-        p_internal->SetState(STATE_EXITED);
+        m_internal->SetState(STATE_EXITED);
+
         return wxTHREAD_NO_RESOURCE;
     }
 
         return wxTHREAD_NO_RESOURCE;
     }
 
@@ -501,7 +1306,12 @@ wxThreadError wxThread::Create()
 
 wxThreadError wxThread::Run()
 {
 
 wxThreadError wxThread::Run()
 {
-    return p_internal->Run();
+    wxCriticalSectionLocker lock(m_critsect);
+
+    wxCHECK_MSG( m_internal->GetId(), wxTHREAD_MISC_ERROR,
+                 wxT("must call wxThread::Create() first") );
+
+    return m_internal->Run();
 }
 
 // -----------------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------------
@@ -512,36 +1322,55 @@ void wxThread::SetPriority(unsigned int prio)
 {
     wxCHECK_RET( ((int)WXTHREAD_MIN_PRIORITY <= (int)prio) &&
                  ((int)prio <= (int)WXTHREAD_MAX_PRIORITY),
 {
     wxCHECK_RET( ((int)WXTHREAD_MIN_PRIORITY <= (int)prio) &&
                  ((int)prio <= (int)WXTHREAD_MAX_PRIORITY),
-                 "invalid thread priority" );
+                 wxT("invalid thread priority") );
 
     wxCriticalSectionLocker lock(m_critsect);
 
 
     wxCriticalSectionLocker lock(m_critsect);
 
-    switch ( p_internal->GetState() )
+    switch ( m_internal->GetState() )
     {
         case STATE_NEW:
             // thread not yet started, priority will be set when it is
     {
         case STATE_NEW:
             // thread not yet started, priority will be set when it is
-            p_internal->SetPriority(prio);
+            m_internal->SetPriority(prio);
             break;
 
         case STATE_RUNNING:
         case STATE_PAUSED:
 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
             break;
 
         case STATE_RUNNING:
         case STATE_PAUSED:
 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
+#if defined(__LINUX__)
+            // On Linux, pthread_setschedparam with SCHED_OTHER does not allow
+            // a priority other than 0.  Instead, we use the BSD setpriority
+            // which alllows us to set a 'nice' value between 20 to -20.  Only
+            // super user can set a value less than zero (more negative yields
+            // higher priority).  setpriority set the static priority of a
+            // process, but this is OK since Linux is configured as a thread
+            // per process.
+            //
+            // FIXME this is not true for 2.6!!
+
+            // map wx priorites WXTHREAD_MIN_PRIORITY..WXTHREAD_MAX_PRIORITY
+            // to Unix priorities 20..-20
+            if ( setpriority(PRIO_PROCESS, 0, -(2*(int)prio)/5 + 20) == -1 )
+            {
+                wxLogError(_("Failed to set thread priority %d."), prio);
+            }
+#else // __LINUX__
             {
                 struct sched_param sparam;
                 sparam.sched_priority = prio;
 
             {
                 struct sched_param sparam;
                 sparam.sched_priority = prio;
 
-                if ( pthread_setschedparam(p_internal->GetId(),
+                if ( pthread_setschedparam(m_internal->GetId(),
                                            SCHED_OTHER, &sparam) != 0 )
                 {
                     wxLogError(_("Failed to set thread priority %d."), prio);
                 }
             }
                                            SCHED_OTHER, &sparam) != 0 )
                 {
                     wxLogError(_("Failed to set thread priority %d."), prio);
                 }
             }
+#endif // __LINUX__
 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS
             break;
 
         case STATE_EXITED:
         default:
 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS
             break;
 
         case STATE_EXITED:
         default:
-            wxFAIL_MSG("impossible to set thread priority in this state");
+            wxFAIL_MSG(wxT("impossible to set thread priority in this state"));
     }
 }
 
     }
 }
 
@@ -549,12 +1378,12 @@ unsigned int wxThread::GetPriority() const
 {
     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
 
 {
     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
 
-    return p_internal->GetPriority();
+    return m_internal->GetPriority();
 }
 
 }
 
-unsigned long wxThread::GetID() const
+wxThreadIdType wxThread::GetId() const
 {
 {
-    return (unsigned long)p_internal->GetId();
+    return (wxThreadIdType) m_internal->GetId();
 }
 
 // -----------------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------------
@@ -563,35 +1392,53 @@ unsigned long wxThread::GetID() const
 
 wxThreadError wxThread::Pause()
 {
 
 wxThreadError wxThread::Pause()
 {
+    wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
+                 wxT("a thread can't pause itself") );
+
     wxCriticalSectionLocker lock(m_critsect);
 
     wxCriticalSectionLocker lock(m_critsect);
 
-    if ( p_internal->GetState() != STATE_RUNNING )
+    if ( m_internal->GetState() != STATE_RUNNING )
     {
     {
-        wxLogDebug("Can't pause thread which is not running.");
+        wxLogDebug(wxT("Can't pause thread which is not running."));
 
         return wxTHREAD_NOT_RUNNING;
     }
 
 
         return wxTHREAD_NOT_RUNNING;
     }
 
-    p_internal->SetState(STATE_PAUSED);
+    // just set a flag, the thread will be really paused only during the next
+    // call to TestDestroy()
+    m_internal->SetState(STATE_PAUSED);
 
     return wxTHREAD_NO_ERROR;
 }
 
 wxThreadError wxThread::Resume()
 {
 
     return wxTHREAD_NO_ERROR;
 }
 
 wxThreadError wxThread::Resume()
 {
+    wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
+                 wxT("a thread can't resume itself") );
+
     wxCriticalSectionLocker lock(m_critsect);
 
     wxCriticalSectionLocker lock(m_critsect);
 
-    if ( p_internal->GetState() == STATE_PAUSED )
-    {
-        p_internal->Resume();
+    wxThreadState state = m_internal->GetState();
 
 
-        return wxTHREAD_NO_ERROR;
-    }
-    else
+    switch ( state )
     {
     {
-        wxLogDebug("Attempt to resume a thread which is not paused.");
+        case STATE_PAUSED:
+            wxLogTrace(TRACE_THREADS, wxT("Thread %p suspended, resuming."),
+                       THR_ID(this));
 
 
-        return wxTHREAD_MISC_ERROR;
+            m_internal->Resume();
+
+            return wxTHREAD_NO_ERROR;
+
+        case STATE_EXITED:
+            wxLogTrace(TRACE_THREADS, wxT("Thread %p exited, won't resume."),
+                       THR_ID(this));
+            return wxTHREAD_NO_ERROR;
+
+        default:
+            wxLogDebug(wxT("Attempt to resume a thread which is not paused."));
+
+            return wxTHREAD_MISC_ERROR;
     }
 }
 
     }
 }
 
@@ -599,98 +1446,231 @@ wxThreadError wxThread::Resume()
 // exiting thread
 // -----------------------------------------------------------------------------
 
 // exiting thread
 // -----------------------------------------------------------------------------
 
-wxThread::ExitCode wxThread::Delete()
+wxThread::ExitCode wxThread::Wait(wxThreadWait WXUNUSED(waitMode))
 {
 {
+    wxCHECK_MSG( This() != this, (ExitCode)-1,
+                 wxT("a thread can't wait for itself") );
+
+    wxCHECK_MSG( !m_isDetached, (ExitCode)-1,
+                 wxT("can't wait for detached thread") );
+
+    m_internal->Wait();
+
+    return m_internal->GetExitCode();
+}
+
+wxThreadError wxThread::Delete(ExitCode *rc, wxThreadWait WXUNUSED(waitMode))
+{
+    wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
+                 wxT("a thread can't delete itself") );
+
+    bool isDetached = m_isDetached;
+
     m_critsect.Enter();
     m_critsect.Enter();
-    wxThreadState state = p_internal->GetState();
-    m_critsect.Leave();
+    wxThreadState state = m_internal->GetState();
 
     // ask the thread to stop
 
     // ask the thread to stop
-    p_internal->SetCancelFlag();
+    m_internal->SetCancelFlag();
+
+    m_critsect.Leave();
+
+    OnDelete();
 
     switch ( state )
     {
         case STATE_NEW:
 
     switch ( state )
     {
         case STATE_NEW:
+            // we need to wake up the thread so that PthreadStart() will
+            // terminate - right now it's blocking on run semaphore in
+            // PthreadStart()
+            m_internal->SignalRun();
+
+            // fall through
+
         case STATE_EXITED:
             // nothing to do
             break;
 
         case STATE_PAUSED:
             // resume the thread first
         case STATE_EXITED:
             // nothing to do
             break;
 
         case STATE_PAUSED:
             // resume the thread first
-            Resume();
+            m_internal->Resume();
 
             // fall through
 
         default:
 
             // fall through
 
         default:
-            // wait until the thread stops
-            p_internal->Wait();
+            if ( !isDetached )
+            {
+                // wait until the thread stops
+                m_internal->Wait();
+
+                if ( rc )
+                {
+                    // return the exit code of the thread
+                    *rc = m_internal->GetExitCode();
+                }
+            }
+            //else: can't wait for detached threads
     }
 
     }
 
-    return NULL;
+    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()
 {
 }
 
 wxThreadError wxThread::Kill()
 {
-    switch ( p_internal->GetState() )
+    wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
+                 wxT("a thread can't kill itself") );
+
+    OnKill();
+
+    switch ( m_internal->GetState() )
     {
         case STATE_NEW:
         case STATE_EXITED:
             return wxTHREAD_NOT_RUNNING;
 
     {
         case STATE_NEW:
         case STATE_EXITED:
             return wxTHREAD_NOT_RUNNING;
 
+        case STATE_PAUSED:
+            // resume the thread first
+            Resume();
+
+            // fall through
+
         default:
         default:
-#ifdef HAVE_PTHREAD_CANCEL 
-            if ( pthread_cancel(p_internal->GetId()) != 0 )
-#endif
+#ifdef HAVE_PTHREAD_CANCEL
+            if ( pthread_cancel(m_internal->GetId()) != 0 )
+#endif // HAVE_PTHREAD_CANCEL
             {
                 wxLogError(_("Failed to terminate a thread."));
 
                 return wxTHREAD_MISC_ERROR;
             }
 
             {
                 wxLogError(_("Failed to terminate a thread."));
 
                 return wxTHREAD_MISC_ERROR;
             }
 
+#ifdef HAVE_PTHREAD_CANCEL
+            if ( m_isDetached )
+            {
+                // if we use cleanup function, this will be done from
+                // wxPthreadCleanup()
+#ifndef wxHAVE_PTHREAD_CLEANUP
+                ScheduleThreadForDeletion();
+
+                // don't call OnExit() here, it can only be called in the
+                // threads context and we're in the context of another thread
+
+                DeleteThread(this);
+#endif // wxHAVE_PTHREAD_CLEANUP
+            }
+            else
+            {
+                m_internal->SetExitCode(EXITCODE_CANCELLED);
+            }
+
             return wxTHREAD_NO_ERROR;
             return wxTHREAD_NO_ERROR;
+#endif // HAVE_PTHREAD_CANCEL
     }
 }
 
     }
 }
 
-void wxThread::Exit(void *status)
+void wxThread::Exit(ExitCode status)
 {
 {
-    // first call user-level clean up code
-    OnExit();
+    wxASSERT_MSG( This() == this,
+                  wxT("wxThread::Exit() can only be called in the context of the same thread") );
+
+    if ( m_isDetached )
+    {
+        // from the moment we call OnExit(), the main program may terminate at
+        // any moment, so mark this thread as being already in process of being
+        // deleted or wxThreadModule::OnExit() will try to delete it again
+        ScheduleThreadForDeletion();
+    }
 
 
-    // next wake up the threads waiting for us (OTOH, this function won't return
-    // until someone waited for us!)
-    p_internal->SignalExit();
+    // don't enter m_critsect before calling OnExit() because the user code
+    // 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)
+    wxTRY
+    {
+        OnExit();
+    }
+    wxCATCH_ALL( wxTheApp->OnUnhandledException(); )
 
 
-    p_internal->SetState(STATE_EXITED);
+    // delete C++ thread object if this is a detached thread - user is
+    // responsible for doing this for joinable ones
+    if ( m_isDetached )
+    {
+        // FIXME I'm feeling bad about it - what if another thread function is
+        //       called (in another thread context) now? It will try to access
+        //       half destroyed object which will probably result in something
+        //       very bad - but we can't protect this by a crit section unless
+        //       we make it a global object, but this would mean that we can
+        //       only call one thread function at a time :-(
+        DeleteThread(this);
+        pthread_setspecific(gs_keySelf, 0);
+    }
+    else
+    {
+        m_critsect.Enter();
+        m_internal->SetState(STATE_EXITED);
+        m_critsect.Leave();
+    }
 
 
-    // delete both C++ thread object and terminate the OS thread object
-    delete this;
+    // terminate the thread (pthread_exit() never returns)
     pthread_exit(status);
     pthread_exit(status);
+
+    wxFAIL_MSG(wxT("pthread_exit() failed"));
 }
 
 // also test whether we were paused
 bool wxThread::TestDestroy()
 {
 }
 
 // also test whether we were paused
 bool wxThread::TestDestroy()
 {
-    wxCriticalSectionLocker lock(m_critsect);
+    wxASSERT_MSG( This() == this,
+                  wxT("wxThread::TestDestroy() can only be called in the context of the same thread") );
 
 
-    if ( p_internal->GetState() == STATE_PAUSED )
+    m_critsect.Enter();
+
+    if ( m_internal->GetState() == STATE_PAUSED )
     {
     {
-        // leave the crit section or the other threads will stop too if they try
-        // to call any of (seemingly harmless) IsXXX() functions while we sleep
-        m_critsect.Leave();
+        m_internal->SetReallyPaused(true);
 
 
-        p_internal->Pause();
+        // leave the crit section or the other threads will stop too if they
+        // try to call any of (seemingly harmless) IsXXX() functions while we
+        // sleep
+        m_critsect.Leave();
 
 
-        // enter it back before it's finally left in lock object dtor
-        m_critsect.Enter();
+        m_internal->Pause();
+    }
+    else
+    {
+        // thread wasn't requested to pause, nothing to do
+        m_critsect.Leave();
     }
 
     }
 
-    return p_internal->WasCancelled();
+    return m_internal->WasCancelled();
 }
 
 wxThread::~wxThread()
 {
 }
 
 wxThread::~wxThread()
 {
+    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(wxT("The thread %p is being destroyed although it is still running! The application may crash."),
+                   THR_ID(this));
+    }
+
+    m_critsect.Leave();
+
+    delete m_internal;
+
     // remove this thread from the global array
     // remove this thread from the global array
-    gs_allThreads.Remove(this);
+    {
+        wxMutexLocker lock(*gs_mutexAllThreads);
+
+        gs_allThreads.Remove(this);
+    }
 }
 
 // -----------------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------------
@@ -701,28 +1681,40 @@ bool wxThread::IsRunning() const
 {
     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
 
 {
     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
 
-    return p_internal->GetState() == STATE_RUNNING;
+    return m_internal->GetState() == STATE_RUNNING;
 }
 
 bool wxThread::IsAlive() const
 {
     wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
 
 }
 
 bool wxThread::IsAlive() const
 {
     wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
 
-    switch ( p_internal->GetState() )
+    switch ( m_internal->GetState() )
     {
         case STATE_RUNNING:
         case STATE_PAUSED:
     {
         case STATE_RUNNING:
         case STATE_PAUSED:
-            return TRUE;
+            return true;
 
         default:
 
         default:
-            return FALSE;
+            return false;
     }
 }
 
     }
 }
 
+bool wxThread::IsPaused() const
+{
+    wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
+
+    return (m_internal->GetState() == STATE_PAUSED);
+}
+
 //--------------------------------------------------------------------
 // wxThreadModule
 //--------------------------------------------------------------------
 
 //--------------------------------------------------------------------
 // wxThreadModule
 //--------------------------------------------------------------------
 
+#ifdef __WXOSX__
+void wxOSXThreadModuleOnInit();
+void wxOSXThreadModuleOnExit();
+#endif
+
 class wxThreadModule : public wxModule
 {
 public:
 class wxThreadModule : public wxModule
 {
 public:
@@ -737,62 +1729,148 @@ IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
 
 bool wxThreadModule::OnInit()
 {
 
 bool wxThreadModule::OnInit()
 {
-    if ( pthread_key_create(&gs_keySelf, NULL /* dtor function */) != 0 )
+    int rc = pthread_key_create(&gs_keySelf, NULL /* dtor function */);
+    if ( rc != 0 )
     {
     {
-        wxLogError(_("Thread module initialization failed: "
-                     "failed to create pthread key."));
+        wxLogSysError(rc, _("Thread module initialization failed: failed to create thread key"));
 
 
-        return FALSE;
+        return false;
     }
 
     }
 
-    gs_mutexGui = new wxMutex();
+    wxThread::ms_idMainThread = wxThread::GetCurrentId();
 
 
-    //wxThreadGuiInit();
+    gs_mutexAllThreads = new wxMutex();
 
 
-    gs_tidMain = pthread_self();
+#ifdef __WXOSX__
+    wxOSXThreadModuleOnInit();
+#else
+    gs_mutexGui = new wxMutex();
     gs_mutexGui->Lock();
     gs_mutexGui->Lock();
+#endif
+
+    gs_mutexDeleteThread = new wxMutex();
+    gs_condAllDeleted = new wxCondition(*gs_mutexDeleteThread);
 
 
-    return TRUE;
+    return true;
 }
 
 void wxThreadModule::OnExit()
 {
 }
 
 void wxThreadModule::OnExit()
 {
-    wxASSERT_MSG( wxThread::IsMain(), "only main thread can be here" );
+    wxASSERT_MSG( wxThread::IsMain(), wxT("only main thread can be here") );
+
+    // are there any threads left which are being deleted right now?
+    size_t nThreadsBeingDeleted;
+
+    {
+        wxMutexLocker lock( *gs_mutexDeleteThread );
+        nThreadsBeingDeleted = gs_nThreadsBeingDeleted;
+
+        if ( nThreadsBeingDeleted > 0 )
+        {
+            wxLogTrace(TRACE_THREADS,
+                       wxT("Waiting for %lu threads to disappear"),
+                       (unsigned long)nThreadsBeingDeleted);
+
+            // have to wait until all of them disappear
+            gs_condAllDeleted->Wait();
+        }
+    }
+
+    size_t count;
+
+    {
+        wxMutexLocker lock(*gs_mutexAllThreads);
 
 
-    // terminate any threads left
-    size_t count = gs_allThreads.GetCount();
-    if ( count != 0u )
-        wxLogDebug("Some threads were not terminated by the application.");
+        // terminate any threads left
+        count = gs_allThreads.GetCount();
+        if ( count != 0u )
+        {
+            wxLogDebug(wxT("%lu threads were not terminated by the application."),
+                       (unsigned long)count);
+        }
+    } // unlock mutex before deleting the threads as they lock it in their dtor
 
     for ( size_t n = 0u; n < count; n++ )
     {
 
     for ( size_t n = 0u; n < count; n++ )
     {
-        gs_allThreads[n]->Delete();
+        // Delete calls the destructor which removes the current entry. We
+        // should only delete the first one each time.
+        gs_allThreads[0]->Delete();
     }
 
     }
 
+    delete gs_mutexAllThreads;
+
+#ifdef __WXOSX__
+    wxOSXThreadModuleOnExit();
+#else
     // destroy GUI mutex
     gs_mutexGui->Unlock();
     // destroy GUI mutex
     gs_mutexGui->Unlock();
-
-    //wxThreadGuiExit();
-
     delete gs_mutexGui;
     delete gs_mutexGui;
+#endif
 
     // and free TLD slot
     (void)pthread_key_delete(gs_keySelf);
 
     // and free TLD slot
     (void)pthread_key_delete(gs_keySelf);
+
+    delete gs_condAllDeleted;
+    delete gs_mutexDeleteThread;
 }
 
 // ----------------------------------------------------------------------------
 // global functions
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // global functions
 // ----------------------------------------------------------------------------
 
-void wxMutexGuiEnter()
+static void ScheduleThreadForDeletion()
+{
+    wxMutexLocker lock( *gs_mutexDeleteThread );
+
+    gs_nThreadsBeingDeleted++;
+
+    wxLogTrace(TRACE_THREADS, wxT("%lu thread%s waiting to be deleted"),
+               (unsigned long)gs_nThreadsBeingDeleted,
+               gs_nThreadsBeingDeleted == 1 ? wxT("") : wxT("s"));
+}
+
+static void DeleteThread(wxThread *This)
+{
+    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,
+                 wxT("no threads scheduled for deletion, yet we delete one?") );
+
+    wxLogTrace(TRACE_THREADS, wxT("%lu threads remain scheduled for deletion."),
+               (unsigned long)gs_nThreadsBeingDeleted - 1);
+
+    if ( !--gs_nThreadsBeingDeleted )
+    {
+        // no more threads left, signal it
+        gs_condAllDeleted->Signal();
+    }
+}
+
+#ifndef __DARWIN__
+
+void wxMutexGuiEnterImpl()
 {
 {
-  gs_mutexGui->Lock();
+    gs_mutexGui->Lock();
 }
 
 }
 
-void wxMutexGuiLeave()
+void wxMutexGuiLeaveImpl()
 {
 {
-  gs_mutexGui->Unlock();
+    gs_mutexGui->Unlock();
 }
 
 #endif
 }
 
 #endif
-  // wxUSE_THREADS
+
+// ----------------------------------------------------------------------------
+// include common implementation code
+// ----------------------------------------------------------------------------
+
+#include "wx/thrimpl.cpp"
+
+#endif // wxUSE_THREADS
wxWidgets (Impactor)