attempts to make wxCondition::Broadcast() and Signal() work simultaneously - currently they do but something else doesn't

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@13931 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/thread.h

@@ -99,8 +99,6 @@ public:
     bool IsLocked() const { return (m_locked > 0); }
 
 protected:
-    friend class wxCondition;
-
     // no assignment operator nor copy ctor
     wxMutex(const wxMutex&);
     wxMutex& operator=(const wxMutex&);
@@ -237,6 +235,11 @@ public:
         // wakes up all threads waiting on this condition
     void Broadcast();
 
+#ifdef __WXDEBUG__
+    // for debugging purposes only
+    void *GetId() const { return m_internal; }
+#endif // __WXDEBUG__
+
 private:
     wxConditionInternal *m_internal;
 };

samples/console/console.cpp

@@ -72,6 +72,7 @@
     #define TEST_LONGLONG
     #define TEST_MIME
     #define TEST_PATHLIST
+    #define TEST_ODBC
     #define TEST_REGCONF
     #define TEST_REGEX
     #define TEST_REGISTRY
@@ -2342,6 +2343,22 @@ static void TestRegExInteractive()
 
 #endif // TEST_REGEX
 
+// ----------------------------------------------------------------------------
+// database
+// ----------------------------------------------------------------------------
+
+#ifdef TEST_ODBC
+
+#include <wx/db.h>
+
+static void TestDbOpen()
+{
+    HENV henv;
+    wxDb db(henv);
+}
+
+#endif // TEST_ODBC
+
 // ----------------------------------------------------------------------------
 // registry and related stuff
 // ----------------------------------------------------------------------------
@@ -4731,9 +4748,6 @@ static void TestThreadDelete()
     puts("");
 }
 
-// wxCondition test code
-// ----------------------------------------------------------------------------
-
 class MyWaitingThread : public wxThread
 {
 public:
@@ -4746,7 +4760,7 @@ public:
 
     virtual ExitCode Entry()
     {
-        printf("Thread %lu has started running.", GetId());
+        printf("Thread %lu has started running.\n", GetId());
         fflush(stdout);
 
         gs_cond.Signal();
@@ -4770,8 +4784,13 @@ static void TestThreadConditions()
 {
     wxCondition condition;
 
+    // otherwise its difficult to understand which log messages pertain to
+    // which condition
+    wxLogTrace("thread", "Local condition var is %08x, gs_cond = %08x",
+               condition.GetId(), gs_cond.GetId());
+
     // create and launch threads
-    MyWaitingThread *threads[2];
+    MyWaitingThread *threads[5];
 
     size_t n;
     for ( n = 0; n < WXSIZEOF(threads); n++ )
@@ -4785,7 +4804,7 @@ static void TestThreadConditions()
     }
 
     // wait until all threads run
-    printf("Main thread is waiting for the threads to start: ");
+    puts("Main thread is waiting for the other threads to start");
     fflush(stdout);
 
     size_t nRunning = 0;
@@ -4793,28 +4812,31 @@ static void TestThreadConditions()
     {
         gs_cond.Wait();
 
-        putchar('.');
-        fflush(stdout);
-
         nRunning++;
+
+        printf("Main thread: %u already running\n", nRunning);
+        fflush(stdout);
     }
 
-    puts("\nMain thread: all threads started up.");
+    puts("Main thread: all threads started up.");
     fflush(stdout);
 
-    // now wake them up
+    wxThread::Sleep(500);
+
 #if 0
+    // now wake one of them up
     printf("Main thread: about to signal the condition.\n");
     fflush(stdout);
     condition.Signal();
-#endif // 0
+#endif
 
+    // wake all the (remaining) threads up, so that they can exit
     printf("Main thread: about to broadcast the condition.\n");
     fflush(stdout);
     condition.Broadcast();
 
-    // give them time to terminate (dirty)
+    // give them time to terminate (dirty!)
-    wxThread::Sleep(300);
+    wxThread::Sleep(500);
 }
 
 #endif // TEST_THREADS
@@ -5581,23 +5603,6 @@ int main(int argc, char **argv)
         TestFtpWuFtpd();
 #endif // TEST_FTP
 
-#ifdef TEST_THREADS
-    int nCPUs = wxThread::GetCPUCount();
-    printf("This system has %d CPUs\n", nCPUs);
-    if ( nCPUs != -1 )
-        wxThread::SetConcurrency(nCPUs);
-
-    if ( 0 )
-    {
-        TestDetachedThreads();
-        TestJoinableThreads();
-        TestThreadSuspend();
-        TestThreadDelete();
-    }
-
-    TestThreadConditions();
-#endif // TEST_THREADS
-
 #ifdef TEST_LONGLONG
     // seed pseudo random generator
     srand((unsigned)time(NULL));
@@ -5629,13 +5634,13 @@ int main(int argc, char **argv)
 
 #ifdef TEST_MIME
     wxLog::AddTraceMask(_T("mime"));
-    if ( 1 )
+    if ( TEST_ALL )
     {
         TestMimeEnum();
         TestMimeOverride();
         TestMimeFilename();
     }
-    else
+
     TestMimeAssociate();
 #endif // TEST_MIME
 
@@ -5652,6 +5657,10 @@ int main(int argc, char **argv)
     TestPathList();
 #endif // TEST_PATHLIST
 
+#ifdef TEST_ODBC
+    TestDbOpen();
+#endif // TEST_ODBC
+
 #ifdef TEST_REGCONF
     TestRegConfWrite();
 #endif // TEST_REGCONF
@@ -5685,6 +5694,23 @@ int main(int argc, char **argv)
     TestMemoryStream();
 #endif // TEST_STREAMS
 
+#ifdef TEST_THREADS
+    int nCPUs = wxThread::GetCPUCount();
+    printf("This system has %d CPUs\n", nCPUs);
+    if ( nCPUs != -1 )
+        wxThread::SetConcurrency(nCPUs);
+
+    if ( TEST_ALL )
+    {
+        TestDetachedThreads();
+        TestJoinableThreads();
+        TestThreadSuspend();
+        TestThreadDelete();
+    }
+
+    TestThreadConditions();
+#endif // TEST_THREADS
+
 #ifdef TEST_TIMER
     TestStopWatch();
 #endif // TEST_TIMER

src/unix/threadpsx.cpp

@@ -7,7 +7,7 @@
 // RCS-ID:      $Id$
 // Copyright:   (c) Wolfram Gloger (1996, 1997)
 //                  Guilhem Lavaux (1998)
-//                  Vadim Zeitlin (1999)
+//                  Vadim Zeitlin (1999-2002)
 //                  Robert Roebling (1999)
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
@@ -34,7 +34,6 @@
 #include "wx/log.h"
 #include "wx/intl.h"
 #include "wx/dynarray.h"
-#include "wx/listimpl.cpp"
 
 #include <stdio.h>
 #include <unistd.h>
@@ -73,6 +72,15 @@ static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1;
 // our trace mask
 #define TRACE_THREADS   _T("thread")
 
+// ----------------------------------------------------------------------------
+// pseudo template types
+// ----------------------------------------------------------------------------
+
+WX_DECLARE_LIST(pthread_mutex_t, wxMutexList);
+
+#include "wx/listimpl.cpp"
+WX_DEFINE_LIST(wxMutexList);
+
 // ----------------------------------------------------------------------------
 // private functions
 // ----------------------------------------------------------------------------
@@ -147,23 +155,29 @@ static wxCondition *gs_condAllDeleted = (wxCondition *)NULL;
 #endif // wxUSE_GUI
 
 // ============================================================================
-// implementation
+// wxMutex implementation
 // ============================================================================
 
-//--------------------------------------------------------------------
+// ----------------------------------------------------------------------------
-// wxMutex (Posix implementation)
+// wxMutexInternal
-//--------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 class wxMutexInternal
 {
 public:
+    wxMutexInternal();
+    ~wxMutexInternal();
+
+    wxMutexError Lock();
+    wxMutexError TryLock();
+    wxMutexError Unlock();
+
+private:
     pthread_mutex_t m_mutex;
 };
 
-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
     //
@@ -174,64 +188,147 @@ wxMutex::wxMutex()
     pthread_mutexattr_init(&attr);
     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 
-    pthread_mutex_init(&(m_internal->m_mutex), &attr);
+    pthread_mutex_init(&m_mutex, &attr);
 #elif defined(HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
     // we can use this only as initializer so we have to assign it first to a
     // temp var - assigning directly to m_mutex wouldn't even compile
     pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
-    m_internal->m_mutex = mutex;
+    m_mutex = mutex;
 #else // no recursive mutexes
-    pthread_mutex_init(&(m_internal->m_mutex), NULL);
+    pthread_mutex_init(&m_mutex, NULL);
+
+    // used by TryLock() below
+    #define NO_RECURSIVE_MUTEXES
 #endif // HAVE_PTHREAD_MUTEXATTR_T/...
+}
+
+wxMutexInternal::~wxMutexInternal()
+{
+    pthread_mutex_destroy(&m_mutex);
+}
+
+wxMutexError wxMutexInternal::Lock()
+{
+    int err = pthread_mutex_lock(&m_mutex);
+    switch ( err )
+    {
+        case EDEADLK:
+            wxLogDebug(wxT("Locking this mutex would lead to deadlock!"));
+            return wxMUTEX_DEAD_LOCK;
+
+        default:
+            wxFAIL_MSG( _T("unexpected pthread_mutex_lock() return") );
+            // fall through
+
+        case EINVAL:
+            wxLogDebug(_T("Failed to lock the mutex."));
+            return wxMUTEX_MISC_ERROR;
+
+        case 0:
+            return wxMUTEX_NO_ERROR;
+    }
+}
+
+wxMutexError wxMutexInternal::TryLock()
+{
+    int err = pthread_mutex_trylock(&m_mutex);
+    switch ( err )
+    {
+        case EBUSY:
+            return wxMUTEX_BUSY;
+
+        default:
+            wxFAIL_MSG( _T("unexpected pthread_mutex_trylock() return") );
+            // fall through
+
+        case EINVAL:
+            wxLogDebug(_T("Failed to try to lock the mutex."));
+            return wxMUTEX_MISC_ERROR;
+
+        case 0:
+            return wxMUTEX_NO_ERROR;
+    }
+}
+
+wxMutexError wxMutexInternal::Unlock()
+{
+    int err = pthread_mutex_unlock(&m_mutex);
+    switch ( err )
+    {
+        case EPERM:
+            // we don't own the mutex
+            return wxMUTEX_UNLOCKED;
+
+        default:
+            wxFAIL_MSG( _T("unexpected pthread_mutex_unlock() return") );
+            // fall through
+
+        case EINVAL:
+            wxLogDebug(_T("Failed to unlock the mutex."));
+            return wxMUTEX_MISC_ERROR;
+
+        case 0:
+            return wxMUTEX_NO_ERROR;
+    }
+}
+
+// ----------------------------------------------------------------------------
+// wxMutex
+// ----------------------------------------------------------------------------
+
+// TODO: this is completely generic, move it to common code?
+
+wxMutex::wxMutex()
+{
+    m_internal = new wxMutexInternal;
 
     m_locked = 0;
 }
 
 wxMutex::~wxMutex()
 {
-    if (m_locked > 0)
+    if ( m_locked > 0 )
         wxLogDebug(wxT("Freeing a locked mutex (%d locks)"), m_locked);
 
-    pthread_mutex_destroy( &(m_internal->m_mutex) );
     delete m_internal;
 }
 
 wxMutexError wxMutex::Lock()
 {
-    int err = pthread_mutex_lock( &(m_internal->m_mutex) );
+    wxMutexError err = m_internal->Lock();
-    if (err == EDEADLK)
-    {
-        wxLogDebug(wxT("Locking this mutex would lead to deadlock!"));
 
-        return wxMUTEX_DEAD_LOCK;
+    if ( !err )
+    {
+        m_locked++;
     }
 
-    m_locked++;
+    return err;
-
-    return wxMUTEX_NO_ERROR;
 }
 
 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
-    int err = pthread_mutex_trylock( &(m_internal->m_mutex) );
+        // we will succeed in locking it when we have it already locked
-    switch (err)
-    {
-        case EBUSY: return wxMUTEX_BUSY;
-    }
-
-    m_locked++;
-
         return wxMUTEX_NO_ERROR;
+#endif // recursive/non-recursive mutexes
+    }
+
+    wxMutexError err = m_internal->TryLock();
+    if ( !err )
+    {
+        m_locked++;
+    }
+
+    return err;
 }
 
 wxMutexError wxMutex::Unlock()
 {
-    if (m_locked > 0)
+    if ( m_locked > 0 )
     {
         m_locked--;
     }
@@ -242,61 +339,67 @@ wxMutexError wxMutex::Unlock()
         return wxMUTEX_UNLOCKED;
     }
 
-    pthread_mutex_unlock( &(m_internal->m_mutex) );
+    return m_internal->Unlock();
-
-    return wxMUTEX_NO_ERROR;
 }
 
-//--------------------------------------------------------------------
+// ============================================================================
-// wxCondition (Posix implementation)
+// wxCondition implementation
-//--------------------------------------------------------------------
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxConditionInternal
+// ----------------------------------------------------------------------------
 
 // 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)
-
-WX_DECLARE_LIST(pthread_mutex_t, wxMutexList);
-
 class wxConditionInternal
 {
 public:
     wxConditionInternal();
     ~wxConditionInternal();
 
-    void Wait();
+    // wait with the given timeout or indefinitely if NULL
-    bool WaitWithTimeout(const timespec* ts);
+    bool Wait(const timespec* ts = NULL);
 
-    void Signal();
+    void Signal(bool all = FALSE);
-    void Broadcast();
-
-    void WaitDone(wxMutexList::Node *mutexnode);
-    wxMutexList::Node *ShouldWait();
-    bool HasWaiters();
 
 private:
-    void LockAllMutexes();          // locks all mutexes on the list
+    // the number of Signal() calls queued
-    void UnlockAllMutexes();       // unlocks mutexes after signaling / broadcasting
+    //
+    // changed by Signal(), accessed by Wait()
+    //
+    // protected by m_mutexSignalCount
+    size_t m_nSignalsMissed;
 
-    // TRUE if condition was signaled while nobody waited for it
+    // protects access to m_nSignalsMissed
-    bool m_wasSignaled;
+    pthread_mutex_t m_mutexSignalCount;
 
-    // protects access to vars above
+    // serializes Broadcast() and/or Signal() calls
-    pthread_mutex_t m_mutexProtect;
+    //
+    // TODO: I'm not sure if this is really needed but it shouldn't harm
+    //       neither (except for efficiency condierations). However MSW doesn't
+    //       do this so maybe we shouldn't do it here neither? (VZ)
+    pthread_mutex_t m_mutexSignal;
 
-    // the mutexes which are used for the condition variable
+    // a condition variable must be always used with a mutex and so we maintain
+    // a list of mutexes - one for each thread that calls Wait().
+    //
+    // access to this list must be protected by m_mutexListContents
     wxMutexList m_mutexes;
 
     // the condition itself
     pthread_cond_t m_condition;
-};
 
-WX_DEFINE_LIST(wxMutexList);
+    // protects all accesses to m_mutexes list
+    pthread_mutex_t m_mutexListContents;
+};
 
 wxConditionInternal::wxConditionInternal()
 {
-    m_wasSignaled = FALSE;
+    m_nSignalsMissed = 0;
 
     if ( pthread_cond_init(&m_condition, (pthread_condattr_t *)NULL) != 0 )
     {
@@ -304,12 +407,13 @@ wxConditionInternal::wxConditionInternal()
         wxFAIL_MSG( _T("pthread_cond_init() failed") );
     }
 
-    if ( pthread_mutex_init(&m_mutexProtect, NULL) != 0 )
+    if ( pthread_mutex_init(&m_mutexSignalCount, NULL) != 0 ||
+         pthread_mutex_init(&m_mutexListContents, NULL) != 0 ||
+         pthread_mutex_init(&m_mutexSignal, NULL) != 0 )
     {
         // neither this
         wxFAIL_MSG( _T("wxCondition: pthread_mutex_init() failed") );
     }
-
 }
 
 wxConditionInternal::~wxConditionInternal()
@@ -320,191 +424,170 @@ wxConditionInternal::~wxConditionInternal()
                       "threads are probably still waiting on it?)"));
     }
 
-    for ( wxMutexList::Node *node = m_mutexes.GetFirst();
+    // the list of waiters mutexes must be empty by now
-          node;
+    wxASSERT_MSG( !m_mutexes.GetFirst(),
-          node = node->GetNext() )
+                  _T("deleting condition someone is still waiting on?") );
-    {
-        pthread_mutex_t *currentmutex = node->GetData();
-        if ( pthread_mutex_unlock( currentmutex ) != 0 )
-        {
-            wxLogDebug(_T("wxCondition: failed to unlock the mutex"));
-        } else {
-            delete currentmutex;
-        }
-    }
 
-    m_mutexes.DeleteContents(TRUE);
+    if ( pthread_mutex_destroy( &m_mutexSignalCount ) != 0 || 
-
+         pthread_mutex_destroy( &m_mutexListContents ) != 0 ||
-    if ( pthread_mutex_destroy( &m_mutexProtect ) != 0 )
+         pthread_mutex_destroy( &m_mutexSignal ) != 0 )
     {
         wxLogDebug(_T("Failed to destroy mutex (it is probably locked)"));
     }
 }
 
-void wxConditionInternal::WaitDone(wxMutexList::Node *mutexnode)
+bool wxConditionInternal::Wait(const timespec* ts)
 {
-    MutexLock lock(m_mutexProtect);
-
-    pthread_mutex_unlock(mutexnode->GetData());
-    pthread_mutex_destroy(mutexnode->GetData());
-    delete mutexnode->GetData();
-
-    m_mutexes.DeleteNode(mutexnode);
-
-}
-
-wxMutexList::Node *wxConditionInternal::ShouldWait()
-{
-    MutexLock lock(m_mutexProtect);
-
-    if ( m_wasSignaled )
     {
-        // the condition was signaled before we started to wait, reset the
+        wxLogTrace(TRACE_THREADS,
-        // flag and return
+                   _T("wxCondition(%08x)::Wait: about to lock missed signal counter"),
-        m_wasSignaled = FALSE;
+                   this);
 
-        return NULL;
+        MutexLock lock(m_mutexSignalCount);
-    }
 
-    // we start to wait for it
+        if ( m_nSignalsMissed )
-
-    pthread_mutex_t *waitmutex = new pthread_mutex_t;
-    if ( pthread_mutex_init(waitmutex, (pthread_mutexattr_t *)NULL) != 0 )
         {
-        // neither this
+            // the condition was signaled before we started to wait, just
-        wxFAIL_MSG( _T("wxCondition: pthread_mutex_init() failed when starting waiting") );
+            // decrease the number of queued signals and return
-    }
+            m_nSignalsMissed--;
 
-    pthread_mutex_lock(waitmutex);
+            wxLogTrace(TRACE_THREADS,
+                       _T("wxCondition(%08x)::Wait: not waiting at all, count = %u"),
+                       this, m_nSignalsMissed);
 
-    return ( m_mutexes.Append(waitmutex) );
-}
-
-bool wxConditionInternal::HasWaiters()
-{
-    if ( m_mutexes.GetCount() )
-    {
-        // someone waits for us, signal the condition normally
             return TRUE;
         }
-
-    // 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;
-
-    return FALSE;
-}
-
-void wxConditionInternal::Wait()
-{
-    wxMutexList::Node *ownmutexnode = ShouldWait();
-
-    if ( ownmutexnode )
-    {
-        if ( pthread_cond_wait( &m_condition, ownmutexnode->GetData() ) != 0 )
-        {
-            // not supposed to ever happen
-            wxFAIL_MSG( _T("pthread_cond_wait() failed") );
     }
 
-        WaitDone(ownmutexnode);
+    // we need to really wait, create a new mutex for this
-    }
+    pthread_mutex_t *mutex = new pthread_mutex_t;
-}
+    if ( pthread_mutex_init(mutex, (pthread_mutexattr_t *)NULL) != 0 )
-
-bool wxConditionInternal::WaitWithTimeout(const timespec* ts)
-{
-    bool ok;
-
-    wxMutexList::Node *ownmutexnode = ShouldWait();
-
-    if ( ownmutexnode )
     {
-        switch ( pthread_cond_timedwait( &m_condition, ownmutexnode->GetData(), ts ) )
+        // not supposed to happen
+        wxFAIL_MSG( _T("pthread_mutex_init() failed when starting waiting") );
+    }
+
+    // lock the mutex before starting to wait on it
+    pthread_mutex_lock(mutex);
+
+    // lock the list before modifying it
+    wxMutexList::Node *mutexNode;
+    {
+        MutexLock lockList(m_mutexListContents);
+
+        mutexNode = m_mutexes.Append(mutex);
+    }
+
+    // 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);
+    int err = ts ? pthread_cond_timedwait(&m_condition, mutex, ts)
+                 : pthread_cond_wait(&m_condition, mutex);
+    switch ( err )
     {
         case 0:
-                // condition signaled
+            // condition was signaled
-                ok = TRUE;
+            wxLogTrace(TRACE_THREADS,
+                       _T("wxCondition(%08x)::Wait(): ok"), this);
             break;
 
         default:
-                wxLogDebug(_T("pthread_cond_timedwait() failed"));
+            wxLogDebug(_T("unexpected pthread_cond_[timed]wait() return"));
-
             // fall through
 
         case ETIMEDOUT:
         case EINTR:
             // wait interrupted or timeout elapsed
-                ok = FALSE;
+            wxLogTrace(TRACE_THREADS,
+                       _T("wxCondition(%08x)::Wait(): timeout/intr"), this);
     }
-        WaitDone(ownmutexnode);
+
-    }
+    // delete the mutex we had used for waiting
-    else
     {
-        // the condition had already been signaled before
+        MutexLock lock(m_mutexListContents);
-        ok = TRUE;
+
+        pthread_mutex_t *m = mutexNode->GetData();
+        pthread_mutex_unlock(m);
+        pthread_mutex_destroy(m);
+        delete m;
+
+        m_mutexes.DeleteNode(mutexNode);
     }
 
-
+    return err == 0;
-    return ok;
 }
 
-void wxConditionInternal::LockAllMutexes()
+void wxConditionInternal::Signal(bool all)
 {
-    wxMutexList::Node *mutexnode = m_mutexes.GetFirst();
+    // make sure that only one Signal() or Broadcast() is in progress
-    while ( mutexnode )
+    MutexLock lock(m_mutexSignal);
+
+    // this mutex has to be locked as well, so that during the entire Signal()
+    // call, no new Wait() is going to wreak havoc (it will block in the very
+    // beginning on this mutex instead)
+    MutexLock lockSignalCount(m_mutexSignalCount);
+
+    wxLogTrace(TRACE_THREADS,
+               _T("wxCondition(%08x)::Signal(): got signal count mutex"),
+               this);
+
     {
-        pthread_mutex_lock(mutexnode->GetData());
+        MutexLock lockList(m_mutexListContents);
-        mutexnode = mutexnode->GetNext();
+
+        if ( !m_mutexes.GetFirst() )
+        {
+            // nobody is waiting for us, just remember that the condition was
+            // signaled and don't do anything else for now
+            m_nSignalsMissed++;
+
+            wxLogTrace(TRACE_THREADS,
+                       _T("wxCondition(%08x)::Signal(): no waiters, count = %u"),
+                       this, m_nSignalsMissed);
+
+            return;
         }
-}
-
-void wxConditionInternal::UnlockAllMutexes()
-{
-    wxMutexList::Node *mutexnode = m_mutexes.GetFirst();
-    while ( mutexnode )
-    {
-        pthread_mutex_unlock(mutexnode->GetData());
-        mutexnode = mutexnode->GetNext();
     }
-}
 
-void wxConditionInternal::Signal()
+    wxLogTrace(TRACE_THREADS,
-{
+               _T("wxCondition(%08x)::Signal(): acquiring all mutexes"), this);
-    // calls to HasWaiters() must be serialized
-    MutexLock lock(m_mutexProtect);
 
-    if ( HasWaiters() )
+    // All mutexes on the list have to be locked. This means that execution of
+    // Signal() goes on as soon as all pending Wait() calls have called
+    // pthread_cond_wait() (where the mutex gets unlocked internally)
+    wxMutexList::Node *node;
+    for ( node = m_mutexes.GetFirst(); node; node = node->GetNext() )
     {
-        // wait 
+        pthread_mutex_lock(node->GetData());
-        LockAllMutexes();
+    }
 
-        if ( pthread_cond_signal( &m_condition ) != 0 )
+    // now we can finally signal it
+    wxLogTrace(TRACE_THREADS, _T("wxCondition(%08x)::Signal(): preparing to %s"),
+               this, all ? _T("broadcast") : _T("signal"));
+
+    int err = all ? pthread_cond_broadcast(&m_condition)
+                  : pthread_cond_signal(&m_condition);
+    if ( err )
     {
         // shouldn't ever happen
-            wxFAIL_MSG(_T("pthread_cond_signal() failed"));
+        wxFAIL_MSG(_T("pthread_cond_{broadcast|signal}() failed"));
     }
 
-        UnlockAllMutexes();
+    // unlock all mutexes so that the threads blocking in their Wait()s could
+    // continue running
+    for ( node = m_mutexes.GetFirst(); node; node = node->GetNext() )
+    {
+        pthread_mutex_unlock(node->GetData());
     }
+
+    wxLogTrace(TRACE_THREADS,
+               _T("wxCondition(%08x)::Signal(): exiting"), this);
 }
 
-void wxConditionInternal::Broadcast()
+// ----------------------------------------------------------------------------
-{
+// wxCondition
-    MutexLock lock(m_mutexProtect);
+// ----------------------------------------------------------------------------
-
-    if ( HasWaiters() )
-    {
-        LockAllMutexes();
-
-        if ( pthread_cond_broadcast( &m_condition ) != 0 )
-        {
-            // shouldn't ever happen
-            wxFAIL_MSG(_T("pthread_cond_broadcast() failed"));
-        }
-
-        UnlockAllMutexes();
-    }
-}
 
 wxCondition::wxCondition()
 {
@@ -518,7 +601,7 @@ wxCondition::~wxCondition()
 
 void wxCondition::Wait()
 {
-    m_internal->Wait();
+    (void)m_internal->Wait();
 }
 
 bool wxCondition::Wait(unsigned long sec, unsigned long nsec)
@@ -528,7 +611,7 @@ bool wxCondition::Wait(unsigned long sec, unsigned long nsec)
     tspec.tv_sec = time(0L) + sec;  // FIXME is time(0) correct here?
     tspec.tv_nsec = nsec;
 
-    return m_internal->WaitWithTimeout(&tspec);
+    return m_internal->Wait(&tspec);
 }
 
 void wxCondition::Signal()
@@ -538,12 +621,12 @@ void wxCondition::Signal()
 
 void wxCondition::Broadcast()
 {
-    m_internal->Broadcast();
+    m_internal->Signal(TRUE /* all */);
 }
 
-//--------------------------------------------------------------------
+// ============================================================================
-// wxThread (Posix implementation)
+// wxThread implementation
-//--------------------------------------------------------------------
+// ============================================================================
 
 // the thread callback functions must have the C linkage
 extern "C"
@@ -558,6 +641,10 @@ void *wxPthreadStart(void *ptr);
 
 } // extern "C"
 
+// ----------------------------------------------------------------------------
+// wxThreadInternal
+// ----------------------------------------------------------------------------
+
 class wxThreadInternal
 {
 public:
@@ -670,6 +757,8 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
 {
     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);