]> 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
wxUniversal fixes:
[wxWidgets.git] / src / unix / threadpsx.cpp
diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp
index e10fe97e82d98353f1d127f6e71afc17424e06d8..72be9193352b2b1191d936e2f62c4e449b37b131 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)
 // 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
 /////////////////////////////////////////////////////////////////////////////
 
@@ -34,13 +35,13 @@
 #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 <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 <sched.h>
 #endif
 #if HAVE_SCHED_H
     #include <sched.h>
 #endif
@@ -80,35 +81,6 @@ static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1;
 static void ScheduleThreadForDeletion();
 static void DeleteThread(wxThread *This);
 
 static void ScheduleThreadForDeletion();
 static void DeleteThread(wxThread *This);
 
-// ----------------------------------------------------------------------------
-// private classes
-// ----------------------------------------------------------------------------
-
-// same as wxMutexLocker but for "native" mutex
-class MutexLock
-{
-public:
-    MutexLock(pthread_mutex_t& mutex)
-    {
-        m_mutex = &mutex;
-        if ( pthread_mutex_lock(m_mutex) != 0 )
-        {
-            wxLogDebug(_T("pthread_mutex_lock() failed"));
-        }
-    }
-
-    ~MutexLock()
-    {
-        if ( pthread_mutex_unlock(m_mutex) != 0 )
-        {
-            wxLogDebug(_T("pthread_mutex_unlock() failed"));
-        }
-    }
-
-private:
-    pthread_mutex_t *m_mutex;
-};
-
 // ----------------------------------------------------------------------------
 // types
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // types
 // ----------------------------------------------------------------------------
@@ -135,7 +107,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
@@ -147,23 +119,31 @@ static wxCondition *gs_condAllDeleted = (wxCondition *)NULL;
 #endif // wxUSE_GUI
 
 // ============================================================================
 #endif // wxUSE_GUI
 
 // ============================================================================
-// implementation
+// wxMutex implementation
 // ============================================================================
 
 // ============================================================================
 
-//--------------------------------------------------------------------
-// wxMutex (Posix implementation)
-//--------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// wxMutexInternal
+// ----------------------------------------------------------------------------
 
 class wxMutexInternal
 {
 public:
 
 class wxMutexInternal
 {
 public:
+    wxMutexInternal();
+    ~wxMutexInternal();
+
+    wxMutexError Lock();
+    wxMutexError TryLock();
+    wxMutexError Unlock();
+
+private:
     pthread_mutex_t m_mutex;
     pthread_mutex_t m_mutex;
+
+    friend class wxConditionInternal;
 };
 
 };
 
-wxMutex::wxMutex()
+wxMutexInternal::wxMutexInternal()
 {
 {
-    m_internal = new wxMutexInternal;
-
     // support recursive locks like Win32, i.e. a thread can lock a mutex which
     // it had itself already locked
     //
     // support recursive locks like Win32, i.e. a thread can lock a mutex which
     // it had itself already locked
     //
@@ -174,64 +154,147 @@ wxMutex::wxMutex()
     pthread_mutexattr_init(&attr);
     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 
     pthread_mutexattr_init(&attr);
     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 
-    pthread_mutex_init(&(m_internal->m_mutex), &attr);
+    pthread_mutex_init(&m_mutex, &attr);
 #elif defined(HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
     // we can use this only as initializer so we have to assign it first to a
     // temp var - assigning directly to m_mutex wouldn't even compile
     pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
 #elif defined(HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
     // we can use this only as initializer so we have to assign it first to a
     // temp var - assigning directly to m_mutex wouldn't even compile
     pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
-    m_internal->m_mutex = mutex;
+    m_mutex = mutex;
 #else // no recursive mutexes
 #else // no recursive mutexes
-    pthread_mutex_init(&(m_internal->m_mutex), NULL);
+    pthread_mutex_init(&m_mutex, NULL);
+
+    // used by TryLock() below
+    #define NO_RECURSIVE_MUTEXES
 #endif // HAVE_PTHREAD_MUTEXATTR_T/...
 #endif // HAVE_PTHREAD_MUTEXATTR_T/...
+}
+
+wxMutexInternal::~wxMutexInternal()
+{
+    pthread_mutex_destroy(&m_mutex);
+}
+
+wxMutexError wxMutexInternal::Lock()
+{
+    int err = pthread_mutex_lock(&m_mutex);
+    switch ( err )
+    {
+        case EDEADLK:
+            wxLogDebug(wxT("Locking this mutex would lead to deadlock!"));
+            return wxMUTEX_DEAD_LOCK;
+
+        default:
+            wxFAIL_MSG( _T("unexpected pthread_mutex_lock() return") );
+            // fall through
+
+        case EINVAL:
+            wxLogDebug(_T("Failed to lock the mutex."));
+            return wxMUTEX_MISC_ERROR;
+
+        case 0:
+            return wxMUTEX_NO_ERROR;
+    }
+}
+
+wxMutexError wxMutexInternal::TryLock()
+{
+    int err = pthread_mutex_trylock(&m_mutex);
+    switch ( err )
+    {
+        case EBUSY:
+            return wxMUTEX_BUSY;
+
+        default:
+            wxFAIL_MSG( _T("unexpected pthread_mutex_trylock() return") );
+            // fall through
+
+        case EINVAL:
+            wxLogDebug(_T("Failed to try to lock the mutex."));
+            return wxMUTEX_MISC_ERROR;
+
+        case 0:
+            return wxMUTEX_NO_ERROR;
+    }
+}
+
+wxMutexError wxMutexInternal::Unlock()
+{
+    int err = pthread_mutex_unlock(&m_mutex);
+    switch ( err )
+    {
+        case EPERM:
+            // we don't own the mutex
+            return wxMUTEX_UNLOCKED;
+
+        default:
+            wxFAIL_MSG( _T("unexpected pthread_mutex_unlock() return") );
+            // fall through
+
+        case EINVAL:
+            wxLogDebug(_T("Failed to unlock the mutex."));
+            return wxMUTEX_MISC_ERROR;
+
+        case 0:
+            return wxMUTEX_NO_ERROR;
+    }
+}
+
+// ----------------------------------------------------------------------------
+// wxMutex
+// ----------------------------------------------------------------------------
+
+// TODO: this is completely generic, move it to common code?
+
+wxMutex::wxMutex()
+{
+    m_internal = new wxMutexInternal;
 
     m_locked = 0;
 }
 
 wxMutex::~wxMutex()
 {
 
     m_locked = 0;
 }
 
 wxMutex::~wxMutex()
 {
-    if (m_locked > 0)
+    if ( m_locked > 0 )
         wxLogDebug(wxT("Freeing a locked mutex (%d locks)"), m_locked);
 
         wxLogDebug(wxT("Freeing a locked mutex (%d locks)"), m_locked);
 
-    pthread_mutex_destroy( &(m_internal->m_mutex) );
     delete m_internal;
 }
 
 wxMutexError wxMutex::Lock()
 {
     delete m_internal;
 }
 
 wxMutexError wxMutex::Lock()
 {
-    int err = pthread_mutex_lock( &(m_internal->m_mutex) );
-    if (err == EDEADLK)
-    {
-        wxLogDebug(wxT("Locking this mutex would lead to deadlock!"));
+    wxMutexError err = m_internal->Lock();
 
 
-        return wxMUTEX_DEAD_LOCK;
+    if ( !err )
+    {
+        m_locked++;
     }
 
     }
 
-    m_locked++;
-
-    return wxMUTEX_NO_ERROR;
+    return err;
 }
 
 wxMutexError wxMutex::TryLock()
 {
 }
 
 wxMutexError wxMutex::TryLock()
 {
-    if (m_locked)
+    if ( m_locked )
     {
     {
-        return wxMUTEX_BUSY;
+#ifdef NO_RECURSIVE_MUTEXES
+        return wxMUTEX_DEAD_LOCK;
+#else // have recursive mutexes on this platform
+        // we will succeed in locking it when we have it already locked
+        return wxMUTEX_NO_ERROR;
+#endif // recursive/non-recursive mutexes
     }
 
     }
 
-    int err = pthread_mutex_trylock( &(m_internal->m_mutex) );
-    switch (err)
+    wxMutexError err = m_internal->TryLock();
+    if ( !err )
     {
     {
-        case EBUSY: return wxMUTEX_BUSY;
+        m_locked++;
     }
 
     }
 
-    m_locked++;
-
-    return wxMUTEX_NO_ERROR;
+    return err;
 }
 
 wxMutexError wxMutex::Unlock()
 {
 }
 
 wxMutexError wxMutex::Unlock()
 {
-    if (m_locked > 0)
+    if ( m_locked > 0 )
     {
         m_locked--;
     }
     {
         m_locked--;
     }
@@ -242,253 +305,371 @@ wxMutexError wxMutex::Unlock()
         return wxMUTEX_UNLOCKED;
     }
 
         return wxMUTEX_UNLOCKED;
     }
 
-    pthread_mutex_unlock( &(m_internal->m_mutex) );
-
-    return wxMUTEX_NO_ERROR;
+    return m_internal->Unlock();
 }
 
 }
 
-//--------------------------------------------------------------------
-// wxCondition (Posix implementation)
-//--------------------------------------------------------------------
+// ===========================================================================
+// wxCondition implementation
+// ===========================================================================
 
 
-// The native POSIX condition variables are dumb: if the condition is signaled
-// before another thread starts to wait on it, the signal is lost and so this
-// other thread will be never woken up. It's much more convenient to us to
-// remember that the condition was signaled and to return from Wait()
-// immediately in this case (this is more like Win32 automatic event objects)
+// ---------------------------------------------------------------------------
+// wxConditionInternal
+// ---------------------------------------------------------------------------
 
 class wxConditionInternal
 {
 public:
 
 class wxConditionInternal
 {
 public:
-    wxConditionInternal();
+    wxConditionInternal(wxMutex& mutex);
     ~wxConditionInternal();
 
     void Wait();
     ~wxConditionInternal();
 
     void Wait();
-    bool WaitWithTimeout(const timespec* ts);
+
+    bool Wait( const timespec *ts );
 
     void Signal();
 
     void Signal();
-    void Broadcast();
 
 
-    void WaitDone();
-    bool ShouldWait();
-    bool HasWaiters();
+    void Broadcast();
 
 private:
 
 private:
-    bool m_wasSignaled;             // TRUE if condition was signaled while
-                                    // nobody waited for it
-    size_t m_nWaiters;              // TRUE if someone already waits for us
-
-    pthread_mutex_t m_mutexProtect; // protects access to vars above
+    // get the POSIX mutex associated with us
+    pthread_mutex_t *GetMutex() const { return &m_mutex.m_internal->m_mutex; }
 
 
-    pthread_mutex_t m_mutex;        // the mutex used with the condition
-    pthread_cond_t m_condition;     // the condition itself
+    wxMutex& m_mutex;
+    pthread_cond_t m_cond;
 };
 
 };
 
-wxConditionInternal::wxConditionInternal()
+wxConditionInternal::wxConditionInternal(wxMutex& mutex)
+                   : m_mutex(mutex)
 {
 {
-    m_wasSignaled = FALSE;
-    m_nWaiters = 0;
-
-    if ( pthread_cond_init(&m_condition, (pthread_condattr_t *)NULL) != 0 )
+    if ( pthread_cond_init( &m_cond, NULL ) != 0 )
     {
     {
-        // this is supposed to never happen
-        wxFAIL_MSG( _T("pthread_cond_init() failed") );
+        wxLogDebug(_T("pthread_cond_init() failed"));
     }
     }
+}
 
 
-    if ( pthread_mutex_init(&m_mutex, (pthread_mutexattr_t *)NULL) != 0 ||
-         pthread_mutex_init(&m_mutexProtect, NULL) != 0 )
+wxConditionInternal::~wxConditionInternal()
+{
+    if ( pthread_cond_destroy( &m_cond ) != 0 )
     {
     {
-        // neither this
-        wxFAIL_MSG( _T("wxCondition: pthread_mutex_init() failed") );
+        wxLogDebug(_T("pthread_cond_destroy() failed"));
     }
     }
+}
 
 
-    // initially the mutex is locked, so no thread can Signal() or Broadcast()
-    // until another thread starts to Wait()
-    if ( pthread_mutex_lock(&m_mutex) != 0 )
+void wxConditionInternal::Wait()
+{
+    if ( pthread_cond_wait( &m_cond, GetMutex() ) != 0 )
     {
     {
-        wxFAIL_MSG( _T("wxCondition: pthread_mutex_lock() failed") );
+        wxLogDebug(_T("pthread_cond_wait() failed"));
     }
 }
 
     }
 }
 
-wxConditionInternal::~wxConditionInternal()
+bool wxConditionInternal::Wait( const timespec *ts )
 {
 {
-    if ( pthread_cond_destroy( &m_condition ) != 0 )
+    int result = pthread_cond_timedwait( &m_cond, GetMutex(), ts );
+    if ( result == ETIMEDOUT )
+        return FALSE;
+
+    if ( result != 0 )
     {
     {
-        wxLogDebug(_T("Failed to destroy condition variable (some "
-                      "threads are probably still waiting on it?)"));
+        wxLogDebug(_T("pthread_cond_timedwait() failed"));
     }
 
     }
 
-    if ( pthread_mutex_unlock( &m_mutex ) != 0 )
-    {
-        wxLogDebug(_T("wxCondition: failed to unlock the mutex"));
+    return TRUE;
+}
+
+void wxConditionInternal::Signal()
+{
+    int result = pthread_cond_signal( &m_cond );
+    if ( result != 0 )
+{
+        wxFAIL_MSG( _T("pthread_cond_signal() failed") );
     }
     }
+}
 
 
-    if ( pthread_mutex_destroy( &m_mutex ) != 0 ||
-         pthread_mutex_destroy( &m_mutexProtect ) != 0 )
-    {
-        wxLogDebug(_T("Failed to destroy mutex (it is probably locked)"));
+void wxConditionInternal::Broadcast()
+{
+    int result = pthread_cond_broadcast( &m_cond );
+    if ( result != 0 )
+{
+        wxFAIL_MSG( _T("pthread_cond_broadcast() failed") );
     }
 }
 
     }
 }
 
-void wxConditionInternal::WaitDone()
+
+// ---------------------------------------------------------------------------
+// wxCondition
+// ---------------------------------------------------------------------------
+
+wxCondition::wxCondition(wxMutex& mutex)
 {
 {
-    MutexLock lock(m_mutexProtect);
+    m_internal = new wxConditionInternal( mutex );
+}
 
 
-    m_wasSignaled = FALSE;
-    m_nWaiters--;
+wxCondition::~wxCondition()
+{
+    delete m_internal;
 }
 
 }
 
-bool wxConditionInternal::ShouldWait()
+void wxCondition::Wait()
 {
 {
-    MutexLock lock(m_mutexProtect);
+    m_internal->Wait();
+}
 
 
-    if ( m_wasSignaled )
-    {
-        // the condition was signaled before we started to wait, reset the
-        // flag and return
-        m_wasSignaled = FALSE;
+bool wxCondition::Wait( unsigned long timeout_millis )
+{
+    wxLongLong curtime = wxGetLocalTimeMillis();
+    curtime += timeout_millis;
+    wxLongLong temp = curtime / 1000;
+    int sec = temp.GetLo();
+    temp = temp * 1000;
+    temp = curtime - temp;
+    int millis = temp.GetLo();
 
 
-        return FALSE;
-    }
+    timespec tspec;
 
 
-    // we start to wait for it
-    m_nWaiters++;
+    tspec.tv_sec = sec;
+    tspec.tv_nsec = millis * 1000L * 1000L;
 
 
-    return TRUE;
+    return m_internal->Wait(&tspec);
 }
 
 }
 
-bool wxConditionInternal::HasWaiters()
+void wxCondition::Signal()
 {
 {
-    MutexLock lock(m_mutexProtect);
+    m_internal->Signal();
+}
 
 
-    if ( m_nWaiters )
-    {
-        // someone waits for us, signal the condition normally
-        return TRUE;
-    }
+void wxCondition::Broadcast()
+{
+    m_internal->Broadcast();
+}
 
 
-    // nobody waits for us and may be never will - so just remember that the
-    // condition was signaled and don't do anything else
-    m_wasSignaled = TRUE;
+// ===========================================================================
+// wxSemaphore implementation
+// ===========================================================================
 
 
-    return FALSE;
-}
+// ---------------------------------------------------------------------------
+// wxSemaphoreInternal
+// ---------------------------------------------------------------------------
 
 
-void wxConditionInternal::Wait()
+class wxSemaphoreInternal
 {
 {
-    if ( ShouldWait() )
+public:
+    wxSemaphoreInternal( int initialcount, int maxcount );
+
+    void Wait();
+    bool TryWait();
+
+    bool Wait( unsigned long timeout_millis );
+
+    void Post();
+
+private:
+    wxMutex m_mutex;
+    wxCondition m_cond;
+
+    int count,
+        maxcount;
+};
+
+wxSemaphoreInternal::wxSemaphoreInternal( int initialcount, int maxcount )
+                   : m_cond(m_mutex)
+{
+
+    if ( (initialcount < 0) || ((maxcount > 0) && (initialcount > maxcount)) )
     {
     {
-        if ( pthread_cond_wait( &m_condition, &m_mutex ) != 0 )
-        {
-            // not supposed to ever happen
-            wxFAIL_MSG( _T("pthread_cond_wait() failed") );
-        }
+        wxFAIL_MSG( _T("wxSemaphore: invalid initial count") );
     }
 
     }
 
-    WaitDone();
+    maxcount = maxcount;
+    count = initialcount;
 }
 
 }
 
-bool wxConditionInternal::WaitWithTimeout(const timespec* ts)
+void wxSemaphoreInternal::Wait()
 {
 {
-    bool ok;
+    wxMutexLocker locker(m_mutex);
 
 
-    if ( ShouldWait() )
+    while ( count <= 0 )
     {
     {
-        switch ( pthread_cond_timedwait( &m_condition, &m_mutex, ts ) )
-        {
-            case 0:
-                // condition signaled
-                ok = TRUE;
-                break;
+        m_cond.Wait();
+    }
 
 
-            default:
-                wxLogDebug(_T("pthread_cond_timedwait() failed"));
+    count--;
+}
 
 
-                // fall through
+bool wxSemaphoreInternal::TryWait()
+{
+    wxMutexLocker locker(m_mutex);
 
 
-            case ETIMEDOUT:
-            case EINTR:
-                // wait interrupted or timeout elapsed
-                ok = FALSE;
-        }
-    }
-    else
-    {
-        // the condition had already been signaled before
-        ok = TRUE;
-    }
+    if ( count <= 0 )
+        return FALSE;
 
 
-    WaitDone();
+    count--;
 
 
-    return ok;
+    return TRUE;
 }
 
 }
 
-void wxConditionInternal::Signal()
+bool wxSemaphoreInternal::Wait( unsigned long timeout_millis )
 {
 {
-    if ( HasWaiters() )
+    wxMutexLocker locker(m_mutex);
+
+    wxLongLong startTime = wxGetLocalTimeMillis();
+
+    while ( count <= 0 )
     {
     {
-        MutexLock lock(m_mutex);
+        wxLongLong elapsed = wxGetLocalTimeMillis() - startTime;
+        long remainingTime = (long)timeout_millis - (long)elapsed.GetLo();
+        if ( remainingTime <= 0 )
+            return FALSE;
 
 
-        if ( pthread_cond_signal( &m_condition ) != 0 )
-        {
-            // shouldn't ever happen
-            wxFAIL_MSG(_T("pthread_cond_signal() failed"));
-        }
+        bool result = m_cond.Wait( remainingTime );
+        if ( !result )
+            return FALSE;
     }
     }
+
+    count--;
+
+    return TRUE;
 }
 
 }
 
-void wxConditionInternal::Broadcast()
+void wxSemaphoreInternal::Post()
 {
 {
-    if ( HasWaiters() )
-    {
-        MutexLock lock(m_mutex);
+    wxMutexLocker locker(m_mutex);
 
 
-        if ( pthread_cond_broadcast( &m_condition ) != 0 )
-        {
-            // shouldn't ever happen
-            wxFAIL_MSG(_T("pthread_cond_broadcast() failed"));
-        }
+    if ( maxcount > 0 && count == maxcount )
+    {
+        wxFAIL_MSG( _T("wxSemaphore::Post() overflow") );
     }
     }
+
+    count++;
+
+    m_cond.Signal();
 }
 
 }
 
-wxCondition::wxCondition()
+// --------------------------------------------------------------------------
+// wxSemaphore
+// --------------------------------------------------------------------------
+
+wxSemaphore::wxSemaphore( int initialcount, int maxcount )
 {
 {
-    m_internal = new wxConditionInternal;
+    m_internal = new wxSemaphoreInternal( initialcount, maxcount );
 }
 
 }
 
-wxCondition::~wxCondition()
+wxSemaphore::~wxSemaphore()
 {
     delete m_internal;
 }
 
 {
     delete m_internal;
 }
 
-void wxCondition::Wait()
+void wxSemaphore::Wait()
 {
     m_internal->Wait();
 }
 
 {
     m_internal->Wait();
 }
 
-bool wxCondition::Wait(unsigned long sec, unsigned long nsec)
+bool wxSemaphore::TryWait()
 {
 {
-    timespec tspec;
-
-    tspec.tv_sec = time(0L) + sec;  // FIXME is time(0) correct here?
-    tspec.tv_nsec = nsec;
-
-    return m_internal->WaitWithTimeout(&tspec);
+    return m_internal->TryWait();
 }
 
 }
 
-void wxCondition::Signal()
+bool wxSemaphore::Wait( unsigned long timeout_millis )
 {
 {
-    m_internal->Signal();
+    return m_internal->Wait( timeout_millis );
 }
 
 }
 
-void wxCondition::Broadcast()
+void wxSemaphore::Post()
 {
 {
-    m_internal->Broadcast();
+    m_internal->Post();
 }
 
 }
 
-//--------------------------------------------------------------------
-// wxThread (Posix implementation)
-//--------------------------------------------------------------------
+// This class is used by wxThreadInternal to support Delete() on
+// a detached thread
+class wxRefCountedCondition
+{
+public:
+    // start with a initial reference count of 1
+    wxRefCountedCondition()
+    {
+        m_refCount = 1;
+        m_signaled = FALSE;
+
+        m_mutex = new wxMutex();
+        m_cond = new wxCondition( *m_mutex );
+    }
+
+    // increment the reference count
+    void AddRef()
+    {
+        wxMutexLocker locker( *m_mutex );
+
+        m_refCount++;
+    }
+
+    // decrement the reference count if reference count is zero then delete the
+    // object
+    void DeleteRef()
+    {
+        bool shouldDelete = FALSE;
+
+        m_mutex->Lock();
+
+        if ( --m_refCount == 0 )
+        {
+            shouldDelete = TRUE;
+        }
+
+        m_mutex->Unlock();
+
+        if ( shouldDelete )
+        {
+            delete this;
+        }
+    }
+
+
+    // sets the object to signaled this signal will be a persistent signal all
+    // further Wait()s on the object will return without blocking
+    void SetSignaled()
+    {
+        wxMutexLocker locker( *m_mutex );
+
+        m_signaled = TRUE;
+
+        m_cond->Broadcast();
+    }
+
+    // wait till the object is signaled if the object was already signaled then
+    // return immediately
+    void Wait()
+    {
+        wxMutexLocker locker( *m_mutex );
+
+        if ( !m_signaled )
+        {
+            m_cond->Wait();
+        }
+    }
+
+private:
+    int m_refCount;
+
+    wxMutex *m_mutex;
+    wxCondition *m_cond;
+
+    bool m_signaled;
+
+    // Cannot delete this object directly, call DeleteRef() instead
+    ~wxRefCountedCondition()
+    {
+        delete m_cond;
+        delete m_mutex;
+    }
+
+    // suppress gcc warning about the class having private dtor and not having
+    // friend (so what??)
+    friend class wxDummyFriend;
+};
+
+// ===========================================================================
+// wxThread implementation
+// ===========================================================================
 
 // the thread callback functions must have the C linkage
 extern "C"
 
 // the thread callback functions must have the C linkage
 extern "C"
@@ -503,6 +684,10 @@ void *wxPthreadStart(void *ptr);
 
 } // extern "C"
 
 
 } // extern "C"
 
+// ----------------------------------------------------------------------------
+// wxThreadInternal
+// ----------------------------------------------------------------------------
+
 class wxThreadInternal
 {
 public:
 class wxThreadInternal
 {
 public:
@@ -520,7 +705,7 @@ public:
         // wake up threads waiting for our termination
     void SignalExit();
         // wake up threads waiting for our start
         // wake up threads waiting for our termination
     void SignalExit();
         // wake up threads waiting for our start
-    void SignalRun() { m_condRun.Signal(); }
+    void SignalRun() { m_semRun.Post(); }
         // go to sleep until Resume() is called
     void Pause();
         // resume the thread
         // go to sleep until Resume() is called
     void Pause();
         // resume the thread
@@ -570,7 +755,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
@@ -584,22 +769,18 @@ private:
     bool m_shouldBroadcast;
     bool m_isDetached;
 
     bool m_shouldBroadcast;
     bool m_isDetached;
 
-    // VZ: it's possible that we might do with less than three different
-    //     condition objects - for example, m_condRun and m_condEnd a priori
-    //     won't be used in the same time. But for now I prefer this may be a
-    //     bit less efficient but safer solution of having distinct condition
-    //     variables for each purpose.
-
-    // this condition is signaled by Run() and the threads Entry() is not
+    // this semaphore is posted by Run() and the threads Entry() is not
     // called before it is done
     // 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;
+    wxSemaphore m_semSuspend;
 
     // finally this one is signalled when the thread exits
 
     // finally this one is signalled when the thread exits
-    wxCondition m_condEnd;
+    // we are using a reference counted condition to support
+    // Delete() for a detached thread
+    wxRefCountedCondition *m_condEnd;
 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------
@@ -615,6 +796,8 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
 {
     wxThreadInternal *pthread = thread->m_internal;
 
 {
     wxThreadInternal *pthread = thread->m_internal;
 
+    wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), pthread->GetId());
+
     // associate the thread pointer with the newly created thread so that
     // wxThread::This() will work
     int rc = pthread_setspecific(gs_keySelf, thread);
     // associate the thread pointer with the newly created thread so that
     // wxThread::This() will work
     int rc = pthread_setspecific(gs_keySelf, thread);
@@ -635,8 +818,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()?
@@ -730,17 +913,20 @@ 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_shouldBroadcast = TRUE;
     m_isDetached = FALSE;
     m_isPaused = FALSE;
 
     // defaults for joinable threads
     m_shouldBeJoined = TRUE;
     m_shouldBroadcast = TRUE;
     m_isDetached = FALSE;
+
+    m_condEnd = new wxRefCountedCondition();
 }
 
 wxThreadInternal::~wxThreadInternal()
 {
 }
 
 wxThreadInternal::~wxThreadInternal()
 {
+    m_condEnd->DeleteRef();
 }
 
 wxThreadError wxThreadInternal::Run()
 }
 
 wxThreadError wxThreadInternal::Run()
@@ -763,17 +949,22 @@ void wxThreadInternal::Wait()
         wxMutexGuiLeave();
 
     bool isDetached = m_isDetached;
         wxMutexGuiLeave();
 
     bool isDetached = m_isDetached;
-#ifdef __VMS
-   long long id = (long long)GetId();
-#else
-   long id = (long)GetId();
-#endif
-   wxLogTrace(TRACE_THREADS, _T("Starting to wait for thread %ld to exit."),
-               id);
+    wxThreadIdType id = (wxThreadIdType) GetId();
+
+    wxLogTrace(TRACE_THREADS,
+               _T("Starting to wait for thread %ld to exit."), id);
 
     // wait until the thread terminates (we're blocking in _another_ thread,
     // of course)
 
     // wait until the thread terminates (we're blocking in _another_ thread,
     // of course)
-    m_condEnd.Wait();
+
+    // a reference counting condition is used to handle the
+    // case where a detached thread deletes itself
+    // before m_condEnd->Wait() returns
+    // in this case the deletion of the condition object is deferred until
+    // all Wait()ing threads have finished calling DeleteRef()
+    m_condEnd->AddRef();
+    m_condEnd->Wait();
+    m_condEnd->DeleteRef();
 
     wxLogTrace(TRACE_THREADS, _T("Finished waiting for thread %ld."), id);
 
 
     wxLogTrace(TRACE_THREADS, _T("Finished waiting for thread %ld."), id);
 
@@ -818,7 +1009,7 @@ void wxThreadInternal::SignalExit()
         wxLogTrace(TRACE_THREADS, _T("Thread %ld signals end condition."),
                    GetId());
 
         wxLogTrace(TRACE_THREADS, _T("Thread %ld signals end condition."),
                    GetId());
 
-        m_condEnd.Broadcast();
+        m_condEnd->SetSignaled();
     }
 }
 
     }
 }
 
@@ -831,8 +1022,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()
@@ -847,7 +1038,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);
@@ -1142,15 +1333,9 @@ unsigned int wxThread::GetPriority() const
     return m_internal->GetPriority();
 }
 
     return m_internal->GetPriority();
 }
 
-#ifdef __VMS
-unsigned long long wxThread::GetId() const
+wxThreadIdType wxThread::GetId() const
 {
 {
-    return (unsigned long long)m_internal->GetId();
-#else
-unsigned long wxThread::GetId() const
-{
-    return (unsigned long)m_internal->GetId();
-#endif
+    return (wxThreadIdType) m_internal->GetId();
 }
 
 // -----------------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------------
@@ -1254,7 +1439,7 @@ wxThreadError wxThread::Delete(ExitCode *rc)
     {
         case STATE_NEW:
             // we need to wake up the thread so that PthreadStart() will
     {
         case STATE_NEW:
             // we need to wake up the thread so that PthreadStart() will
-            // terminate - right now it's blocking on m_condRun
+            // terminate - right now it's blocking on m_semRun
             m_internal->SignalRun();
 
             // fall through
             m_internal->SignalRun();
 
             // fall through
@@ -1437,7 +1622,8 @@ wxThread::~wxThread()
     // is not called for the joinable threads, so do it here
     if ( !m_isDetached )
     {
     // is not called for the joinable threads, so do it here
     if ( !m_isDetached )
     {
-        MutexLock lock(gs_mutexDeleteThread);
+        wxMutexLocker lock( *gs_mutexDeleteThread );
+
         gs_nThreadsBeingDeleted--;
 
         wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."),
         gs_nThreadsBeingDeleted--;
 
         wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."),
@@ -1513,9 +1699,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;
 }
@@ -1526,18 +1711,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
@@ -1564,6 +1750,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;
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -1572,12 +1761,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++;
 
@@ -1590,17 +1774,15 @@ 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,
+    wxCHECK_RET( gs_nThreadsBeingDeleted > 0,
                      _T("no threads scheduled for deletion, yet we delete "
                         "one?") );
                      _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);
@@ -1609,9 +1791,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;
     }
 }
 
     }
 }
 
wxWidgets (Impactor)