remove temportay fix to Makefile.in, now configure .in is fixed

[wxWidgets.git] / src / unix / threadpsx.cpp

diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp
index 5e8ba134236f1b5b4b89bf2642aff45488963a77..36d6ee7d0ebc6a7b2927de8ac13ca5ccc70a63cc 100644 (file)
--- a/src/unix/threadpsx.cpp
+++ b/src/unix/threadpsx.cpp
@@ -2,13 +2,14 @@
 // Name:        threadpsx.cpp
 // Purpose:     wxThread (Posix) Implementation
 // Author:      Original from Wolfram Gloger/Guilhem Lavaux
 // Name:        threadpsx.cpp
 // Purpose:     wxThread (Posix) Implementation
 // Author:      Original from Wolfram Gloger/Guilhem Lavaux

-// Modified by:
+// Modified by: K. S. Sreeram (2002): POSIXified wxCondition, added wxSemaphore

 // Created:     04/22/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Wolfram Gloger (1996, 1997)
 //                  Guilhem Lavaux (1998)
 //                  Vadim Zeitlin (1999-2002)
 //                  Robert Roebling (1999)
 // Created:     04/22/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Wolfram Gloger (1996, 1997)
 //                  Guilhem Lavaux (1998)
 //                  Vadim Zeitlin (1999-2002)
 //                  Robert Roebling (1999)

+//                  K. S. Sreeram (2002)

 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 


@@ -34,6 +35,7 @@
 #include "wx/log.h"
 #include "wx/intl.h"
 #include "wx/dynarray.h"
 #include "wx/log.h"
 #include "wx/intl.h"
 #include "wx/dynarray.h"

+#include "wx/timer.h"

 
 #include <stdio.h>
 #include <unistd.h>
 
 #include <stdio.h>
 #include <unistd.h>


@@ -69,17 +71,11 @@ enum wxThreadState
 // the exit value of a thread which has been cancelled
 static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1;
 
 // the exit value of a thread which has been cancelled
 static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1;
 

-// our trace mask
+// trace mask for wxThread operations

 #define TRACE_THREADS   _T("thread")
 
 #define TRACE_THREADS   _T("thread")
 

-// ----------------------------------------------------------------------------
-// pseudo template types
-// ----------------------------------------------------------------------------
-
-WX_DECLARE_LIST(pthread_mutex_t, wxMutexList);
-
-#include "wx/listimpl.cpp"
-WX_DEFINE_LIST(wxMutexList);
+// you can get additional debugging messages for the semaphore operations
+#define TRACE_SEMA      _T("semaphore")

 
 // ----------------------------------------------------------------------------
 // private functions
 
 // ----------------------------------------------------------------------------
 // private functions


@@ -92,37 +88,11 @@ static void DeleteThread(wxThread *This);
 // private classes
 // ----------------------------------------------------------------------------
 
 // private classes
 // ----------------------------------------------------------------------------
 

-// same as wxMutexLocker but for "native" mutex
-class MutexLock
-{
-public:
-    MutexLock(pthread_mutex_t& mutex)
-    {
-        m_mutex = &mutex;
-        if ( pthread_mutex_lock(m_mutex) != 0 )
-        {
-            wxLogDebug(_T("pthread_mutex_lock() failed"));
-        }
-    }
-
-    ~MutexLock()
-    {
-        if ( pthread_mutex_unlock(m_mutex) != 0 )
-        {
-            wxLogDebug(_T("pthread_mutex_unlock() failed"));
-        }
-    }
-
-private:
-    pthread_mutex_t *m_mutex;
-};
-
-// ----------------------------------------------------------------------------
-// types
-// ----------------------------------------------------------------------------
-
+// an (non owning) array of pointers to threads

 WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
 
 WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
 

+// an entry for a thread we can wait for
+

 // -----------------------------------------------------------------------------
 // global data
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 // global data
 // -----------------------------------------------------------------------------


@@ -143,7 +113,7 @@ static pthread_key_t gs_keySelf;
 static size_t gs_nThreadsBeingDeleted = 0;
 
 // a mutex to protect gs_nThreadsBeingDeleted
 static size_t gs_nThreadsBeingDeleted = 0;
 
 // a mutex to protect gs_nThreadsBeingDeleted

-static pthread_mutex_t gs_mutexDeleteThread;
+static wxMutex *gs_mutexDeleteThread = (wxMutex *)NULL;

 
 // and a condition variable which will be signaled when all
 // gs_nThreadsBeingDeleted will have been deleted
 
 // and a condition variable which will be signaled when all
 // gs_nThreadsBeingDeleted will have been deleted


@@ -154,6 +124,15 @@ static wxCondition *gs_condAllDeleted = (wxCondition *)NULL;
     static wxMutex *gs_mutexGui;
 #endif // wxUSE_GUI
 
     static wxMutex *gs_mutexGui;
 #endif // wxUSE_GUI
 

+// 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
+

 // ============================================================================
 // wxMutex implementation
 // ============================================================================
 // ============================================================================
 // wxMutex implementation
 // ============================================================================


@@ -162,49 +141,86 @@ static wxCondition *gs_condAllDeleted = (wxCondition *)NULL;
 // wxMutexInternal
 // ----------------------------------------------------------------------------
 
 // wxMutexInternal
 // ----------------------------------------------------------------------------
 

+// this is a simple wrapper around pthread_mutex_t which provides error
+// checking

 class wxMutexInternal
 {
 public:
 class wxMutexInternal
 {
 public:

-    wxMutexInternal();
+    wxMutexInternal(wxMutexType mutexType);

     ~wxMutexInternal();
 
     wxMutexError Lock();
     wxMutexError TryLock();
     wxMutexError Unlock();
 
     ~wxMutexInternal();
 
     wxMutexError Lock();
     wxMutexError TryLock();
     wxMutexError Unlock();
 

+    bool IsOk() const { return m_isOk; }
+

 private:
     pthread_mutex_t m_mutex;
 private:
     pthread_mutex_t m_mutex;

+    bool m_isOk;
+
+    // wxConditionInternal uses our m_mutex
+    friend class wxConditionInternal;

 };
 
 };
 

-wxMutexInternal::wxMutexInternal()
+wxMutexInternal::wxMutexInternal(wxMutexType mutexType)

 {
 {

-    // support recursive locks like Win32, i.e. a thread can lock a mutex which
-    // it had itself already locked
-    //
-    // but initialization of recursive mutexes is non portable <sigh>, so try
-    // several methods
+    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
 #ifdef HAVE_PTHREAD_MUTEXATTR_T

-    pthread_mutexattr_t attr;
-    pthread_mutexattr_init(&attr);
-    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+            {
+                pthread_mutexattr_t attr;
+                pthread_mutexattr_init(&attr);
+                pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);

 
 

-    pthread_mutex_init(&m_mutex, &attr);
+                err = pthread_mutex_init(&m_mutex, &attr);
+            }

 #elif defined(HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
 #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;
+            // 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
 #else // no recursive mutexes

-    pthread_mutex_init(&m_mutex, NULL);
-
-    // used by TryLock() below
-    #define NO_RECURSIVE_MUTEXES
+            err = EINVAL;

 #endif // HAVE_PTHREAD_MUTEXATTR_T/...
 #endif // HAVE_PTHREAD_MUTEXATTR_T/...

+            break;
+
+        default:
+            wxFAIL_MSG( _T("unknown mutex type") );
+            // fall through
+
+        case wxMUTEX_DEFAULT:
+            err = pthread_mutex_init(&m_mutex, NULL);
+            break;
+    }
+
+    m_isOk = err == 0;
+    if ( !m_isOk )
+    {
+        wxLogApiError("pthread_mutex_init()", err);
+    }

 }
 
 wxMutexInternal::~wxMutexInternal()
 {
 }
 
 wxMutexInternal::~wxMutexInternal()
 {

-    pthread_mutex_destroy(&m_mutex);
+    if ( m_isOk )
+    {
+        int err = pthread_mutex_destroy(&m_mutex);
+        if ( err != 0 )
+        {
+            wxLogApiError("pthread_mutex_destroy()", err);
+        }
+    }

 }
 
 wxMutexError wxMutexInternal::Lock()
 }
 
 wxMutexError wxMutexInternal::Lock()


@@ -213,20 +229,23 @@ wxMutexError wxMutexInternal::Lock()
     switch ( err )
     {
         case EDEADLK:
     switch ( err )
     {
         case EDEADLK:

-            wxLogDebug(wxT("Locking this mutex would lead to deadlock!"));
+            // 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") );

             return wxMUTEX_DEAD_LOCK;
 
             return wxMUTEX_DEAD_LOCK;
 

-        default:
-            wxFAIL_MSG( _T("unexpected pthread_mutex_lock() return") );
-            // fall through
-

         case EINVAL:
         case EINVAL:

-            wxLogDebug(_T("Failed to lock the mutex."));
-            return wxMUTEX_MISC_ERROR;
+            wxLogDebug(_T("pthread_mutex_lock(): mutex not initialized."));
+            break;

 
         case 0:
             return wxMUTEX_NO_ERROR;
 
         case 0:
             return wxMUTEX_NO_ERROR;

+
+        default:
+            wxLogApiError(_T("pthread_mutex_lock()"), err);

     }
     }

+
+    return wxMUTEX_MISC_ERROR;

 }
 
 wxMutexError wxMutexInternal::TryLock()
 }
 
 wxMutexError wxMutexInternal::TryLock()


@@ -235,19 +254,22 @@ wxMutexError wxMutexInternal::TryLock()
     switch ( err )
     {
         case EBUSY:
     switch ( err )
     {
         case EBUSY:

+            // not an error: mutex is already locked, but we're prepared for
+            // this

             return wxMUTEX_BUSY;
 
             return wxMUTEX_BUSY;
 

-        default:
-            wxFAIL_MSG( _T("unexpected pthread_mutex_trylock() return") );
-            // fall through
-

         case EINVAL:
         case EINVAL:

-            wxLogDebug(_T("Failed to try to lock the mutex."));
-            return wxMUTEX_MISC_ERROR;
+            wxLogDebug(_T("pthread_mutex_trylock(): mutex not initialized."));
+            break;

 
         case 0:
             return wxMUTEX_NO_ERROR;
 
         case 0:
             return wxMUTEX_NO_ERROR;

+
+        default:
+            wxLogApiError(_T("pthread_mutex_trylock()"), err);

     }
     }

+
+    return wxMUTEX_MISC_ERROR;

 }
 
 wxMutexError wxMutexInternal::Unlock()
 }
 
 wxMutexError wxMutexInternal::Unlock()


@@ -259,292 +281,285 @@ wxMutexError wxMutexInternal::Unlock()
             // we don't own the mutex
             return wxMUTEX_UNLOCKED;
 
             // we don't own the mutex
             return wxMUTEX_UNLOCKED;
 

-        default:
-            wxFAIL_MSG( _T("unexpected pthread_mutex_unlock() return") );
-            // fall through
-

         case EINVAL:
         case EINVAL:

-            wxLogDebug(_T("Failed to unlock the mutex."));
-            return wxMUTEX_MISC_ERROR;
+            wxLogDebug(_T("pthread_mutex_unlock(): mutex not initialized."));
+            break;

 
         case 0:
             return wxMUTEX_NO_ERROR;
 
         case 0:
             return wxMUTEX_NO_ERROR;

+
+        default:
+            wxLogApiError(_T("pthread_mutex_unlock()"), err);

     }
     }

+
+    return wxMUTEX_MISC_ERROR;

 }
 
 }
 

-// ----------------------------------------------------------------------------
-// wxMutex
-// ----------------------------------------------------------------------------
+// ===========================================================================
+// wxCondition implementation
+// ===========================================================================

 
 

-// TODO: this is completely generic, move it to common code?
+// ---------------------------------------------------------------------------
+// wxConditionInternal
+// ---------------------------------------------------------------------------

 
 

-wxMutex::wxMutex()
+// this is a wrapper around pthread_cond_t associated with a wxMutex (and hence
+// with a pthread_mutex_t)
+class wxConditionInternal

 {
 {

-    m_internal = new wxMutexInternal;
+public:
+    wxConditionInternal(wxMutex& mutex);
+    ~wxConditionInternal();

 
 

-    m_locked = 0;
-}
+    bool IsOk() const { return m_isOk && m_mutex.IsOk(); }

 
 

-wxMutex::~wxMutex()
-{
-    if ( m_locked > 0 )
-        wxLogDebug(wxT("Freeing a locked mutex (%d locks)"), m_locked);
+    wxCondError Wait();
+    wxCondError WaitTimeout(unsigned long milliseconds);

 
 

-    delete m_internal;
-}
+    wxCondError Signal();
+    wxCondError Broadcast();

 
 

-wxMutexError wxMutex::Lock()
+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)

 {
 {

-    wxMutexError err = m_internal->Lock();
+    int err = pthread_cond_init(&m_cond, NULL /* default attributes */);
+
+    m_isOk = err == 0;

 
 

-    if ( !err )
+    if ( !m_isOk )

     {
     {

-        m_locked++;
+        wxLogApiError(_T("pthread_cond_init()"), err);

     }
     }

+}

 
 

-    return err;
+wxConditionInternal::~wxConditionInternal()
+{
+    if ( m_isOk )
+    {
+        int err = pthread_cond_destroy(&m_cond);
+        if ( err != 0 )
+        {
+            wxLogApiError(_T("pthread_cond_destroy()"), err);
+        }
+    }

 }
 
 }
 

-wxMutexError wxMutex::TryLock()
+wxCondError wxConditionInternal::Wait()

 {
 {

-    if ( m_locked )
+    int err = pthread_cond_wait(&m_cond, GetPMutex());
+    if ( err != 0 )

     {
     {

-#ifdef NO_RECURSIVE_MUTEXES
-        return wxMUTEX_DEAD_LOCK;
-#else // have recursive mutexes on this platform
-        // we will succeed in locking it when we have it already locked
-        return wxMUTEX_NO_ERROR;
-#endif // recursive/non-recursive mutexes
+        wxLogApiError(_T("pthread_cond_wait()"), err);
+
+        return wxCOND_MISC_ERROR;

     }
 
     }
 

-    wxMutexError err = m_internal->TryLock();
-    if ( !err )
+    return wxCOND_NO_ERROR;
+}
+
+wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds)
+{
+    wxLongLong curtime = wxGetLocalTimeMillis();
+    curtime += milliseconds;
+    wxLongLong temp = curtime / 1000;
+    int sec = temp.GetLo();
+    temp *= 1000;
+    temp = curtime - temp;
+    int millis = temp.GetLo();
+
+    timespec tspec;
+
+    tspec.tv_sec = sec;
+    tspec.tv_nsec = millis * 1000L * 1000L;
+
+    int err = pthread_cond_timedwait( &m_cond, GetPMutex(), &tspec );
+    switch ( err )

     {
     {

-        m_locked++;
+        case ETIMEDOUT:
+            return wxCOND_TIMEOUT;
+
+        case 0:
+            return wxCOND_NO_ERROR;
+
+        default:
+            wxLogApiError(_T("pthread_cond_timedwait()"), err);

     }
 
     }
 

-    return err;
+    return wxCOND_MISC_ERROR;

 }
 
 }
 

-wxMutexError wxMutex::Unlock()
+wxCondError wxConditionInternal::Signal()

 {
 {

-    if ( m_locked > 0 )
+    int err = pthread_cond_signal(&m_cond);
+    if ( err != 0 )

     {
     {

-        m_locked--;
+        wxLogApiError(_T("pthread_cond_signal()"), err);
+
+        return wxCOND_MISC_ERROR;

     }
     }

-    else
+
+    return wxCOND_NO_ERROR;
+}
+
+wxCondError wxConditionInternal::Broadcast()
+{
+    int err = pthread_cond_broadcast(&m_cond);
+    if ( err != 0 )

     {
     {

-        wxLogDebug(wxT("Unlocking not locked mutex."));
+        wxLogApiError(_T("pthread_cond_broadcast()"), err);

 
 

-        return wxMUTEX_UNLOCKED;
+        return wxCOND_MISC_ERROR;

     }
 
     }
 

-    return m_internal->Unlock();
+    return wxCOND_NO_ERROR;

 }
 
 }
 

-// ============================================================================
-// wxCondition implementation
-// ============================================================================
+// ===========================================================================
+// wxSemaphore implementation
+// ===========================================================================

 
 

-// ----------------------------------------------------------------------------
-// wxConditionInternal
-// ----------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// wxSemaphoreInternal
+// ---------------------------------------------------------------------------

 
 

-// The native POSIX condition variables are dumb: if the condition is signaled
-// before another thread starts to wait on it, the signal is lost and so this
-// other thread will be never woken up. It's much more convenient to us to
-// remember that the condition was signaled and to return from Wait()
-// immediately in this case (this is more like Win32 automatic event objects)
-class wxConditionInternal
+// 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:

-    wxConditionInternal();
-    ~wxConditionInternal();
+    wxSemaphoreInternal(int initialcount, int maxcount);

 
 

-    // wait with the given timeout or indefinitely if NULL
-    bool Wait(const timespec* ts = NULL);
+    bool IsOk() const { return m_isOk; }

 
 

-    void Signal(bool all = FALSE);
+    wxSemaError Wait();
+    wxSemaError TryWait();
+    wxSemaError WaitTimeout(unsigned long milliseconds);

 
 

-private:
-    // the number of Signal() calls we "missed", i.e. which were done while
-    // there were no threads to wait for them
-    size_t m_nQueuedSignals;
+    wxSemaError Post();

 
 

-    // counts all pending waiters
-    size_t m_nWaiters;
+private:
+    wxMutex m_mutex;
+    wxCondition m_cond;

 
 

-    // the condition itself
-    pthread_cond_t m_condition;
+    size_t m_count,
+           m_maxcount;

 
 

-    // the mutex used with the conditon: it also protects the counters above
-    pthread_mutex_t m_mutex;
+    bool m_isOk;

 };
 
 };
 

-wxConditionInternal::wxConditionInternal()
+wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
+                   : m_cond(m_mutex)

 {
 {

-    m_nQueuedSignals =
-    m_nWaiters = 0;

 
 

-    if ( pthread_cond_init(&m_condition, (pthread_condattr_t *)NULL) != 0 )
+    if ( (initialcount < 0 || maxcount < 0) ||
+            ((maxcount > 0) && (initialcount > maxcount)) )

     {
     {

-        // this is supposed to never happen
-        wxFAIL_MSG( _T("pthread_cond_init() failed") );
-    }
+        wxFAIL_MSG( _T("wxSemaphore: invalid initial or maximal count") );

 
 

-    if ( pthread_mutex_init(&m_mutex, NULL) != 0 )
-    {
-        // neither this
-        wxFAIL_MSG( _T("wxCondition: pthread_mutex_init() failed") );
+        m_isOk = FALSE;

     }
     }

-}
-
-wxConditionInternal::~wxConditionInternal()
-{
-    if ( pthread_cond_destroy( &m_condition ) != 0 )
+    else

     {
     {

-        wxLogDebug(_T("Failed to destroy condition variable (some "
-                      "threads are probably still waiting on it?)"));
+        m_maxcount = (size_t)maxcount;
+        m_count = (size_t)initialcount;

     }
 
     }
 

-    if ( pthread_mutex_destroy( &m_mutex ) != 0 ) 
-    {
-        wxLogDebug(_T("Failed to destroy mutex (it is probably locked)"));
-    }
+    m_isOk = m_mutex.IsOk() && m_cond.IsOk();

 }
 
 }
 

-bool wxConditionInternal::Wait(const timespec* ts)
+wxSemaError wxSemaphoreInternal::Wait()

 {
 {

-    MutexLock lock(m_mutex);
+    wxMutexLocker locker(m_mutex);

 
 

-    if ( m_nQueuedSignals )
+    while ( m_count == 0 )

     {
     {

-        m_nQueuedSignals--;
+        wxLogTrace(TRACE_SEMA,
+                   "Thread %ld waiting for semaphore to become signalled",
+                   wxThread::GetCurrentId());

 
 

-        wxLogTrace(TRACE_THREADS,
-                   _T("wxCondition(%08x)::Wait(): Has been signaled before"),
-                   this);
+        if ( m_cond.Wait() != wxCOND_NO_ERROR )
+            return wxSEMA_MISC_ERROR;

 
 

-        return TRUE;
+        wxLogTrace(TRACE_SEMA,
+                   "Thread %ld finished waiting for semaphore, count = %u",
+                   wxThread::GetCurrentId(), m_count);

     }
 
     }
 

-    // there are no queued signals, so start really waiting
-    m_nWaiters++;
+    m_count--;

 
 

-    // calling wait function below unlocks the mutex and Signal() or
-    // Broadcast() will be able to continue to run now if they were
-    // blocking for it in the loop locking all mutexes)
-    wxLogTrace(TRACE_THREADS,
-               _T("wxCondition(%08x)::Wait(): starting to wait"), this);
+    return wxSEMA_NO_ERROR;
+}

 
 

-    int err = ts ? pthread_cond_timedwait(&m_condition, &m_mutex, ts)
-                 : pthread_cond_wait(&m_condition, &m_mutex);
-    switch ( err )
-    {
-        case 0:
-            // condition was signaled
-            wxLogTrace(TRACE_THREADS,
-                       _T("wxCondition(%08x)::Wait(): ok"), this);
-            break;
+wxSemaError wxSemaphoreInternal::TryWait()
+{
+    wxMutexLocker locker(m_mutex);

 
 

-        default:
-            wxLogDebug(_T("unexpected pthread_cond_[timed]wait() return"));
-            // fall through
+    if ( m_count == 0 )
+        return wxSEMA_BUSY;

 
 

-        case ETIMEDOUT:
-        case EINTR:
-            // The condition has not been signaled, so we have to
-            // decrement the counter manually
-            --m_nWaiters;
-
-            // wait interrupted or timeout elapsed
-            wxLogTrace(TRACE_THREADS,
-                       _T("wxCondition(%08x)::Wait(): timeout/intr"), this);
-    }
+    m_count--;

 
 

-    return err == 0;
+    return wxSEMA_NO_ERROR;

 }
 
 }
 

-void wxConditionInternal::Signal(bool all)
+wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds)

 {
 {

-    // make sure that only one Signal() or Broadcast() is in progress
-    MutexLock lock(m_mutex);
-
-    // Are there any waiters?
-    if ( m_nWaiters == 0 )
-    {
-        // No, there are not, so don't signal but keep in mind for the next
-        // Wait()
-        m_nQueuedSignals++;
+    wxMutexLocker locker(m_mutex);

 
 

-        return;
-    }
-
-    // now we can finally signal it
-    wxLogTrace(TRACE_THREADS, _T("wxCondition(%08x)::Signal(): preparing to %s"),
-               this, all ? _T("broadcast") : _T("signal"));
+    wxLongLong startTime = wxGetLocalTimeMillis();

 
 

-    int err = all ? pthread_cond_broadcast(&m_condition)
-                  : pthread_cond_signal(&m_condition);
-
-    if ( all )
+    while ( m_count == 0 )

     {
     {

-        m_nWaiters = 0;
-    }
-    else
-    {
-        --m_nWaiters;
-    }
+        wxLongLong elapsed = wxGetLocalTimeMillis() - startTime;
+        long remainingTime = (long)milliseconds - (long)elapsed.GetLo();
+        if ( remainingTime <= 0 )
+        {
+            // timeout
+            return wxSEMA_TIMEOUT;
+        }

 
 

-    if ( err )
-    {
-        // shouldn't ever happen
-        wxFAIL_MSG(_T("pthread_cond_{broadcast|signal}() failed"));
+        if ( m_cond.Wait(remainingTime) != wxCOND_NO_ERROR )
+            return wxSEMA_MISC_ERROR;

     }
     }

-}

 
 

-// ----------------------------------------------------------------------------
-// wxCondition
-// ----------------------------------------------------------------------------
-
-wxCondition::wxCondition()
-{
-    m_internal = new wxConditionInternal;
-}
-
-wxCondition::~wxCondition()
-{
-    delete m_internal;
-}
+    m_count--;

 
 

-void wxCondition::Wait()
-{
-    (void)m_internal->Wait();
+    return wxSEMA_NO_ERROR;

 }
 
 }
 

-bool wxCondition::Wait(unsigned long sec, unsigned long nsec)
+wxSemaError wxSemaphoreInternal::Post()

 {
 {

-    timespec tspec;
+    wxMutexLocker locker(m_mutex);

 
 

-    tspec.tv_sec = time(0L) + sec;  // FIXME is time(0) correct here?
-    tspec.tv_nsec = nsec;
+    if ( m_maxcount > 0 && m_count == m_maxcount )
+    {
+        return wxSEMA_OVERFLOW;
+    }

 
 

-    return m_internal->Wait(&tspec);
-}
+    m_count++;

 
 

-void wxCondition::Signal()
-{
-    m_internal->Signal();
+    wxLogTrace(TRACE_SEMA,
+               "Thread %ld about to signal semaphore, count = %u",
+               wxThread::GetCurrentId(), m_count);
+    
+    return m_cond.Signal() == wxCOND_NO_ERROR ? wxSEMA_NO_ERROR
+                                              : wxSEMA_MISC_ERROR;

 }
 
 }
 

-void wxCondition::Broadcast()
-{
-    m_internal->Signal(TRUE /* all */);
-}
-
-// ============================================================================
+// ===========================================================================

 // wxThread implementation
 // wxThread implementation

-// ============================================================================
+// ===========================================================================

 
 // the thread callback functions must have the C linkage
 extern "C"
 
 // the thread callback functions must have the C linkage
 extern "C"


@@ -575,12 +590,10 @@ public:
     // 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();
-        // wake up threads waiting for our start
-    void SignalRun() { m_condRun.Signal(); }

         // go to sleep until Resume() is called
     void Pause();
         // resume the thread
         // go to sleep until Resume() is called
     void Pause();
         // resume the thread


@@ -592,7 +605,23 @@ 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)
+    {
+#ifdef __WXDEBUG__
+        static const wxChar *stateNames[] =
+        {
+            _T("NEW"),
+            _T("RUNNING"),
+            _T("PAUSED"),
+            _T("EXITED"),
+        };
+
+        wxLogTrace(TRACE_THREADS, _T("Thread %ld: %s => %s."),
+                   GetId(), stateNames[m_state], stateNames[state]);
+#endif // __WXDEBUG__
+
+        m_state = state;
+    }

         // id
     pthread_t GetId() const { return m_threadId; }
     pthread_t *GetIdPtr() { return &m_threadId; }
         // id
     pthread_t GetId() const { return m_threadId; }
     pthread_t *GetIdPtr() { return &m_threadId; }


@@ -610,12 +639,11 @@ public:
         // tell the thread that it is a detached one
     void Detach()
     {
         // tell the thread that it is a detached one
     void Detach()
     {

-        m_shouldBeJoined = m_shouldBroadcast = FALSE;
+        wxCriticalSectionLocker lock(m_csJoinFlag);
+
+        m_shouldBeJoined = FALSE;

         m_isDetached = TRUE;
     }
         m_isDetached = TRUE;
     }

-        // but even detached threads need to notifyus about their termination
-        // sometimes - tell the thread that it should do it
-    void Notify() { m_shouldBroadcast = TRUE; }

 
 #if HAVE_THREAD_CLEANUP_FUNCTIONS
     // this is used by wxPthreadCleanup() only
 
 #if HAVE_THREAD_CLEANUP_FUNCTIONS
     // this is used by wxPthreadCleanup() only


@@ -630,7 +658,7 @@ private:
     // this flag is set when the thread should terminate
     bool m_cancelled;
 
     // this flag is set when the thread should terminate
     bool m_cancelled;
 

-    // this flag is set when the thread is blocking on m_condSuspend
+    // this flag is set when the thread is blocking on m_semSuspend

     bool m_isPaused;
 
     // the thread exit code - only used for joinable (!detached) threads and
     bool m_isPaused;
 
     // the thread exit code - only used for joinable (!detached) threads and


@@ -641,25 +669,15 @@ private:
     // pthread_join(), so we have to keep track of this
     wxCriticalSection m_csJoinFlag;
     bool m_shouldBeJoined;
     // pthread_join(), so we have to keep track of this
     wxCriticalSection m_csJoinFlag;
     bool m_shouldBeJoined;

-    bool m_shouldBroadcast;

     bool m_isDetached;
 
     bool m_isDetached;
 

-    // VZ: it's possible that we might do with less than three different
-    //     condition objects - for example, m_condRun and m_condEnd a priori
-    //     won't be used in the same time. But for now I prefer this may be a
-    //     bit less efficient but safer solution of having distinct condition
-    //     variables for each purpose.
-
-    // this condition is signaled by Run() and the threads Entry() is not
+    // this semaphore is posted by Run() and the threads Entry() is not

     // called before it is done
     // called before it is done

-    wxCondition m_condRun;
+    wxSemaphore m_semRun;

 
     // this one is signaled when the thread should resume after having been
     // Pause()d
 
     // this one is signaled when the thread should resume after having been
     // Pause()d

-    wxCondition m_condSuspend;
-
-    // finally this one is signalled when the thread exits
-    wxCondition m_condEnd;
+    wxSemaphore m_semSuspend;

 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------


@@ -697,8 +715,8 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
     pthread_cleanup_push(wxPthreadCleanup, thread);
 #endif // HAVE_THREAD_CLEANUP_FUNCTIONS
 
     pthread_cleanup_push(wxPthreadCleanup, thread);
 #endif // HAVE_THREAD_CLEANUP_FUNCTIONS
 

-    // wait for the condition to be signaled from Run()
-    pthread->m_condRun.Wait();
+    // wait for the semaphore to be posted from Run()
+    pthread->m_semRun.Wait();

 
     // test whether we should run the run at all - may be it was deleted
     // before it started to Run()?
 
     // test whether we should run the run at all - may be it was deleted
     // before it started to Run()?


@@ -712,17 +730,17 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
     if ( !dontRunAtAll )
     {
         // call the main entry
     if ( !dontRunAtAll )
     {
         // call the main entry

+        wxLogTrace(TRACE_THREADS, _T("Thread %ld about to enter its Entry()."),
+                   pthread->GetId());
+

         pthread->m_exitcode = thread->Entry();
 
         pthread->m_exitcode = thread->Entry();
 

-        wxLogTrace(TRACE_THREADS, _T("Thread %ld left its Entry()."),
-                   pthread->GetId());
+        wxLogTrace(TRACE_THREADS, _T("Thread %ld Entry() returned %lu."),
+                   pthread->GetId(), (unsigned long)pthread->m_exitcode);

 
         {
             wxCriticalSectionLocker lock(thread->m_critsect);
 
 
         {
             wxCriticalSectionLocker lock(thread->m_critsect);
 

-            wxLogTrace(TRACE_THREADS, _T("Thread %ld changes state to EXITED."),
-                       pthread->GetId());
-

             // 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)
             // 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)


@@ -740,6 +758,7 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
 
     if ( dontRunAtAll )
     {
 
     if ( dontRunAtAll )
     {

+        // FIXME: deleting a possibly joinable thread here???

         delete thread;
 
         return EXITCODE_CANCELLED;
         delete thread;
 
         return EXITCODE_CANCELLED;


@@ -792,12 +811,11 @@ wxThreadInternal::wxThreadInternal()
     m_threadId = 0;
     m_exitcode = 0;
 
     m_threadId = 0;
     m_exitcode = 0;
 

-    // set to TRUE only when the thread starts waiting on m_condSuspend
+    // set to TRUE only when the thread starts waiting on m_semSuspend

     m_isPaused = FALSE;
 
     // defaults for joinable threads
     m_shouldBeJoined = TRUE;
     m_isPaused = FALSE;
 
     // defaults for joinable threads
     m_shouldBeJoined = TRUE;

-    m_shouldBroadcast = TRUE;

     m_isDetached = FALSE;
 }
 
     m_isDetached = FALSE;
 }
 


@@ -810,38 +828,29 @@ wxThreadError wxThreadInternal::Run()
     wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
                  wxT("thread may only be started once after Create()") );
 
     wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
                  wxT("thread may only be started once after Create()") );
 

-    SignalRun();
-

     SetState(STATE_RUNNING);
 
     SetState(STATE_RUNNING);
 

+    // wake up threads waiting for our start
+    SignalRun();
+

     return wxTHREAD_NO_ERROR;
 }
 
 void wxThreadInternal::Wait()
 {
     return wxTHREAD_NO_ERROR;
 }
 
 void wxThreadInternal::Wait()
 {

+    wxCHECK_RET( !m_isDetached, _T("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() )
         wxMutexGuiLeave();
 
     // 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() )
         wxMutexGuiLeave();
 

-    bool isDetached = m_isDetached;
-    wxThreadIdType id = (wxThreadIdType) GetId();
-

     wxLogTrace(TRACE_THREADS,
     wxLogTrace(TRACE_THREADS,

-               _T("Starting to wait for thread %ld to exit."), id);
-
-    // wait until the thread terminates (we're blocking in _another_ thread,
-    // of course)
-    m_condEnd.Wait();
-
-    wxLogTrace(TRACE_THREADS, _T("Finished waiting for thread %ld."), id);
+               _T("Starting to wait for thread %ld to exit."), GetId());

 
 

-    // we can't use any member variables any more if the thread is detached
-    // because it could be already deleted
-    if ( !isDetached )
+    // 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

     {
     {

-        // to avoid memory leaks we should call pthread_join(), but it must
-        // only be done once

         wxCriticalSectionLocker lock(m_csJoinFlag);
 
         if ( m_shouldBeJoined )
         wxCriticalSectionLocker lock(m_csJoinFlag);
 
         if ( m_shouldBeJoined )


@@ -850,8 +859,12 @@ void wxThreadInternal::Wait()
             //       we're cancelled inside pthread_join(), things will almost
             //       certainly break - but if we disable the cancellation, we
             //       might deadlock
             //       we're cancelled inside pthread_join(), things will almost
             //       certainly break - but if we disable the cancellation, we
             //       might deadlock

-            if ( pthread_join((pthread_t)id, &m_exitcode) != 0 )
+            if ( pthread_join((pthread_t)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"));
             }
                 wxLogError(_("Failed to join a thread, potential memory leak "
                              "detected - please restart the program"));
             }


@@ -865,22 +878,6 @@ void wxThreadInternal::Wait()
         wxMutexGuiEnter();
 }
 
         wxMutexGuiEnter();
 }
 

-void wxThreadInternal::SignalExit()
-{
-    wxLogTrace(TRACE_THREADS, _T("Thread %ld about to exit."), GetId());
-
-    SetState(STATE_EXITED);
-
-    // wake up all the threads waiting for our termination - if there are any
-    if ( m_shouldBroadcast )
-    {
-        wxLogTrace(TRACE_THREADS, _T("Thread %ld signals end condition."),
-                   GetId());
-
-        m_condEnd.Broadcast();
-    }
-}
-

 void wxThreadInternal::Pause()
 {
     // the state is set from the thread which pauses us first, this function
 void wxThreadInternal::Pause()
 {
     // the state is set from the thread which pauses us first, this function


@@ -890,8 +887,8 @@ void wxThreadInternal::Pause()
 
     wxLogTrace(TRACE_THREADS, _T("Thread %ld goes to sleep."), GetId());
 
 
     wxLogTrace(TRACE_THREADS, _T("Thread %ld goes to sleep."), GetId());
 

-    // wait until the condition is signaled from Resume()
-    m_condSuspend.Wait();
+    // wait until the semaphore is Post()ed from Resume()
+    m_semSuspend.Wait();

 }
 
 void wxThreadInternal::Resume()
 }
 
 void wxThreadInternal::Resume()


@@ -906,7 +903,7 @@ void wxThreadInternal::Resume()
         wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), GetId());
 
         // wake up Pause()
         wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), GetId());
 
         // wake up Pause()

-        m_condSuspend.Signal();
+        m_semSuspend.Post();

 
         // reset the flag
         SetReallyPaused(FALSE);
 
         // reset the flag
         SetReallyPaused(FALSE);


@@ -1224,9 +1221,6 @@ wxThreadError wxThread::Pause()
         return wxTHREAD_NOT_RUNNING;
     }
 
         return wxTHREAD_NOT_RUNNING;
     }
 

-    wxLogTrace(TRACE_THREADS, _T("Asking thread %ld to pause."),
-               GetId());
-

     // just set a flag, the thread will be really paused only during the next
     // call to TestDestroy()
     m_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);


@@ -1287,27 +1281,22 @@ wxThreadError wxThread::Delete(ExitCode *rc)
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
                  _T("a thread can't delete itself") );
 
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
                  _T("a thread can't delete itself") );
 

+    bool isDetached = m_isDetached;
+

     m_critsect.Enter();
     wxThreadState state = m_internal->GetState();
 
     // ask the thread to stop
     m_internal->SetCancelFlag();
 
     m_critsect.Enter();
     wxThreadState state = m_internal->GetState();
 
     // ask the thread to stop
     m_internal->SetCancelFlag();
 

-    if ( m_isDetached )
-    {
-        // detached threads won't broadcast about their termination by default
-        // because usually nobody waits for them - but here we do, so ask the
-        // thread to notify us
-        m_internal->Notify();
-    }
-

     m_critsect.Leave();
 
     switch ( state )
     {
         case STATE_NEW:
             // we need to wake up the thread so that PthreadStart() will
     m_critsect.Leave();
 
     switch ( state )
     {
         case STATE_NEW:
             // we need to wake up the thread so that PthreadStart() will

-            // terminate - right now it's blocking on m_condRun
+            // terminate - right now it's blocking on run semaphore in
+            // PthreadStart()

             m_internal->SignalRun();
 
             // fall through
             m_internal->SignalRun();
 
             // fall through


@@ -1317,24 +1306,24 @@ wxThreadError wxThread::Delete(ExitCode *rc)
             break;
 
         case STATE_PAUSED:
             break;
 
         case STATE_PAUSED:

-            // resume the thread first (don't call our Resume() because this
-            // would dead lock when it tries to enter m_critsect)
+            // resume the thread first

             m_internal->Resume();
 
             // fall through
 
         default:
             m_internal->Resume();
 
             // fall through
 
         default:

-            // wait until the thread stops
-            m_internal->Wait();
-
-            if ( rc )
+            if ( !isDetached )

             {
             {

-                wxASSERT_MSG( !m_isDetached,
-                              _T("no return code for detached threads") );
+                // wait until the thread stops
+                m_internal->Wait();

 
 

-                // if it's a joinable thread, it's not deleted yet
-                *rc = m_internal->GetExitCode();
+                if ( rc )
+                {
+                    // return the exit code of the thread
+                    *rc = m_internal->GetExitCode();
+                }

             }
             }

+            //else: can't wait for detached threads

     }
 
     return wxTHREAD_NO_ERROR;
     }
 
     return wxTHREAD_NO_ERROR;


@@ -1395,10 +1384,13 @@ void wxThread::Exit(ExitCode status)
                   _T("wxThread::Exit() can only be called in the "
                      "context of the same thread") );
 
                   _T("wxThread::Exit() can only be called in the "
                      "context of the same thread") );
 

-    // 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();
+    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();
+    }

 
     // don't enter m_critsect before calling OnExit() because the user code
     // might deadlock if, for example, it signals a condition in OnExit() (a
 
     // don't enter m_critsect before calling OnExit() because the user code
     // might deadlock if, for example, it signals a condition in OnExit() (a


@@ -1406,17 +1398,6 @@ void wxThread::Exit(ExitCode status)
     // m_critsect on us (almost all of them do)
     OnExit();
 
     // m_critsect on us (almost all of them do)
     OnExit();
 

-    // now do enter it because SignalExit() will change our state
-    m_critsect.Enter();
-
-    // next wake up the threads waiting for us (OTOH, this function won't return
-    // until someone waited for us!)
-    m_internal->SignalExit();
-
-    // leave the critical section before entering the dtor which tries to
-    // enter it
-    m_critsect.Leave();
-

     // delete C++ thread object if this is a detached thread - user is
     // responsible for doing this for joinable ones
     if ( m_isDetached )
     // delete C++ thread object if this is a detached thread - user is
     // responsible for doing this for joinable ones
     if ( m_isDetached )


@@ -1485,17 +1466,6 @@ wxThread::~wxThread()
 
     // remove this thread from the global array
     gs_allThreads.Remove(this);
 
     // remove this thread from the global array
     gs_allThreads.Remove(this);

-
-    // detached thread will decrement this counter in DeleteThread(), but it
-    // is not called for the joinable threads, so do it here
-    if ( !m_isDetached )
-    {
-        MutexLock lock(gs_mutexDeleteThread);
-        gs_nThreadsBeingDeleted--;
-
-        wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."),
-                   gs_nThreadsBeingDeleted - 1);
-    }

 }
 
 // -----------------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------------


@@ -1566,9 +1536,8 @@ bool wxThreadModule::OnInit()
     gs_mutexGui->Lock();
 #endif // wxUSE_GUI
 
     gs_mutexGui->Lock();
 #endif // wxUSE_GUI
 

-    // under Solaris we get a warning from CC when using
-    // PTHREAD_MUTEX_INITIALIZER, so do it dynamically
-    pthread_mutex_init(&gs_mutexDeleteThread, NULL);
+    gs_mutexDeleteThread = new wxMutex();
+    gs_condAllDeleted = new wxCondition( *gs_mutexDeleteThread );

 
     return TRUE;
 }
 
     return TRUE;
 }


@@ -1579,18 +1548,19 @@ void wxThreadModule::OnExit()
 
     // are there any threads left which are being deleted right now?
     size_t nThreadsBeingDeleted;
 
     // are there any threads left which are being deleted right now?
     size_t nThreadsBeingDeleted;

+

     {
     {

-        MutexLock lock(gs_mutexDeleteThread);
+        wxMutexLocker lock( *gs_mutexDeleteThread );

         nThreadsBeingDeleted = gs_nThreadsBeingDeleted;
         nThreadsBeingDeleted = gs_nThreadsBeingDeleted;

-    }

 
 

-    if ( nThreadsBeingDeleted > 0 )
-    {
-        wxLogTrace(TRACE_THREADS, _T("Waiting for %u threads to disappear"),
-                   nThreadsBeingDeleted);
+        if ( nThreadsBeingDeleted > 0 )
+        {
+            wxLogTrace(TRACE_THREADS, _T("Waiting for %u threads to disappear"),
+                       nThreadsBeingDeleted);

 
 

-        // have to wait until all of them disappear
-        gs_condAllDeleted->Wait();
+            // have to wait until all of them disappear
+            gs_condAllDeleted->Wait();
+        }

     }
 
     // terminate any threads left
     }
 
     // terminate any threads left


@@ -1617,6 +1587,9 @@ void wxThreadModule::OnExit()
 
     // 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;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -1625,12 +1598,7 @@ void wxThreadModule::OnExit()
 
 static void ScheduleThreadForDeletion()
 {
 
 static void ScheduleThreadForDeletion()
 {

-    MutexLock lock(gs_mutexDeleteThread);
-
-    if ( gs_nThreadsBeingDeleted == 0 )
-    {
-        gs_condAllDeleted = new wxCondition;
-    }
+    wxMutexLocker lock( *gs_mutexDeleteThread );

 
     gs_nThreadsBeingDeleted++;
 
 
     gs_nThreadsBeingDeleted++;
 


@@ -1643,17 +1611,14 @@ static void DeleteThread(wxThread *This)
 {
     // gs_mutexDeleteThread should be unlocked before signalling the condition
     // or wxThreadModule::OnExit() would deadlock
 {
     // gs_mutexDeleteThread should be unlocked before signalling the condition
     // or wxThreadModule::OnExit() would deadlock

-    {
-        MutexLock lock(gs_mutexDeleteThread);
+    wxMutexLocker locker( *gs_mutexDeleteThread );

 
 

-        wxLogTrace(TRACE_THREADS, _T("Thread %ld auto deletes."), This->GetId());
+    wxLogTrace(TRACE_THREADS, _T("Thread %ld auto deletes."), This->GetId());

 
 

-        delete This;
+    delete This;

 
 

-        wxCHECK_RET( gs_nThreadsBeingDeleted > 0,
-                     _T("no threads scheduled for deletion, yet we delete "
-                        "one?") );
-    }
+    wxCHECK_RET( gs_nThreadsBeingDeleted > 0,
+                 _T("no threads scheduled for deletion, yet we delete one?") );

 
     wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."),
                gs_nThreadsBeingDeleted - 1);
 
     wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."),
                gs_nThreadsBeingDeleted - 1);


@@ -1662,9 +1627,6 @@ static void DeleteThread(wxThread *This)
     {
         // no more threads left, signal it
         gs_condAllDeleted->Signal();
     {
         // no more threads left, signal it
         gs_condAllDeleted->Signal();

-
-        delete gs_condAllDeleted;
-        gs_condAllDeleted = (wxCondition *)NULL;

     }
 }
 
     }
 }
 


@@ -1682,5 +1644,11 @@ void wxMutexGuiLeave()
 #endif // wxUSE_GUI
 }
 
 #endif // wxUSE_GUI
 }
 

-#endif
-  // wxUSE_THREADS
+// ----------------------------------------------------------------------------
+// include common implementation code
+// ----------------------------------------------------------------------------
+
+#include "wx/thrimpl.cpp"
+
+#endif // wxUSE_THREADS
+