X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/0dac2f38ef7da9ce4456f439a4628708d95d840a..866592d872daa1f4e3d44948d7d3a6c90b0af9d0:/src/unix/threadpsx.cpp?ds=sidebyside

diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp
index 8548b18014..c3a6ff6268 100644
--- a/src/unix/threadpsx.cpp
+++ b/src/unix/threadpsx.cpp
@@ -47,10 +47,6 @@
     #include <sched.h>
 #endif
 
-#ifdef __WXGTK12__
-#include "gtk/gtk.h"
-#endif
-
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
@@ -85,10 +81,8 @@ static pthread_t gs_tidMain;
 // the key for the pointer to the associated wxThread object
 static pthread_key_t gs_keySelf;
 
-#ifndef __WXGTK12__
 // this mutex must be acquired before any call to a GUI function
 static wxMutex *gs_mutexGui;
-#endif
 
 // ============================================================================
 // implementation
@@ -107,6 +101,7 @@ public:
 wxMutex::wxMutex()
 {
     p_internal = new wxMutexInternal;
+    
     pthread_mutex_init( &(p_internal->p_mutex), (const pthread_mutexattr_t*) NULL );
     m_locked = 0;
 }
@@ -277,6 +272,8 @@ private:
     //     state
     //  2. The Delete() function blocks until the condition is signaled when the
     //     thread exits.
+    // GL: On Linux, this may fail because we can have a deadlock in either
+    //     SignalExit() or Wait(): so we add m_end_mutex for the finalization.
     wxMutex     m_mutex, m_end_mutex;
     wxCondition m_cond;
 
@@ -311,7 +308,6 @@ void *wxThreadInternal::PthreadStart(void *ptr)
     // wait for the condition to be signaled from Run()
     // mutex state: currently locked by the thread which created us
     pthread->m_cond.Wait(pthread->m_mutex);
-
     // mutex state: locked again on exit of Wait()
 
     // call the main entry
@@ -360,6 +356,9 @@ wxThreadInternal::wxThreadInternal()
     // unlocked in the very end
     m_mutex.Lock();
  
+    // this mutex is used by wxThreadInternal::Wait() and by
+    // wxThreadInternal::SignalExit(). We don't use m_mutex because of a
+    // possible deadlock in either Wait() or SignalExit().
     m_end_mutex.Lock();
 
     // this mutex is used in Pause()/Resume() and is also locked all the time
@@ -374,7 +373,17 @@ wxThreadInternal::~wxThreadInternal()
 
     // note that m_mutex will be unlocked by the thread which waits for our
     // termination
-    m_end_mutex.Unlock();
+
+    // In the case, we didn't start the thread, all these mutex are locked:
+    // we must unlock them.
+    if (m_mutex.IsLocked())
+      m_mutex.Unlock();
+
+    if (m_end_mutex.IsLocked())
+      m_end_mutex.Unlock();
+
+    if (m_mutexSuspend.IsLocked())
+      m_mutexSuspend.Unlock();
 }
 
 wxThreadError wxThreadInternal::Run()
@@ -406,16 +415,17 @@ void wxThreadInternal::Wait()
     if ( wxThread::IsMain() )
         wxMutexGuiLeave();
 
-    printf("Entering wait ...\n");
     // entering Wait() releases the mutex thus allowing SignalExit() to acquire
     // it and to signal us its termination
     m_cond.Wait(m_end_mutex);
-    printf("Exiting wait ...\n");
 
     // mutex is still in the locked state - relocked on exit from Wait(), so
     // unlock it - we don't need it any more, the thread has already terminated
     m_end_mutex.Unlock();
 
+    // After that, we wait for the real end of the other thread.
+    pthread_join(GetId(), NULL);
+
     // reacquire GUI mutex
     if ( wxThread::IsMain() )
         wxMutexGuiEnter();
@@ -423,21 +433,18 @@ void wxThreadInternal::Wait()
 
 void wxThreadInternal::SignalExit()
 {
-    printf("SignalExit\n");
     // GL: Unlock mutexSuspend here.
     m_mutexSuspend.Unlock();
 
     // as mutex is currently locked, this will block until some other thread
     // (normally the same which created this one) unlocks it by entering Wait()
     m_end_mutex.Lock();
-    printf("Mutex acquired\n");
 
     // wake up all the threads waiting for our termination
     m_cond.Broadcast();
 
     // after this call mutex will be finally unlocked
     m_end_mutex.Unlock();
-    printf("Mutex unacquired\n");
 }
 
 void wxThreadInternal::Pause()
@@ -662,13 +669,17 @@ wxThreadError wxThread::Resume()
 
 wxThread::ExitCode wxThread::Delete()
 {
+    if (IsPaused())
+      Resume();
+
     m_critsect.Enter();
     wxThreadState state = p_internal->GetState();
-    m_critsect.Leave();
 
     // ask the thread to stop
     p_internal->SetCancelFlag();
 
+    m_critsect.Leave();
+
     switch ( state )
     {
         case STATE_NEW:
@@ -686,6 +697,8 @@ wxThread::ExitCode wxThread::Delete()
             // wait until the thread stops
             p_internal->Wait();
     }
+    //GL: As we must auto-destroy, the destruction must happen here.
+    delete this;
 
     return NULL;
 }
@@ -707,6 +720,8 @@ wxThreadError wxThread::Kill()
 
                 return wxTHREAD_MISC_ERROR;
             }
+	    //GL: As we must auto-destroy, the destruction must happen here (2).
+	    delete this;
 
             return wxTHREAD_NO_ERROR;
     }
@@ -716,20 +731,16 @@ void wxThread::Exit(void *status)
 {
     // first call user-level clean up code
     OnExit();
-    printf(" ... OnExit()\n");
 
     // next wake up the threads waiting for us (OTOH, this function won't return
     // until someone waited for us!)
     p_internal->SignalExit();
-    printf(" ... SignalExit()\n");
 
     p_internal->SetState(STATE_EXITED);
-    printf(" ... SetState()\n");
 
     // delete both C++ thread object and terminate the OS thread object
     // GL: This is very ugly and buggy ...
 //    delete this;
-    printf(" ... Exit\n");
     pthread_exit(status);
 }
 
@@ -755,6 +766,14 @@ bool wxThread::TestDestroy()
 
 wxThread::~wxThread()
 {
+    m_critsect.Enter();
+    if (p_internal->GetState() != STATE_EXITED &&
+        p_internal->GetState() != STATE_NEW)
+      wxLogDebug(_T("The thread is being destroyed althought it is still running ! The application may crash."));
+
+    m_critsect.Leave();
+
+    delete p_internal;
     // remove this thread from the global array
     gs_allThreads.Remove(this);
 }
@@ -819,15 +838,11 @@ bool wxThreadModule::OnInit()
         return FALSE;
     }
 
-#ifndef __WXGTK12__
     gs_mutexGui = new wxMutex();
-#endif
 
     gs_tidMain = pthread_self();
 
-#ifndef __WXGTK12__
     gs_mutexGui->Lock();
-#endif
 
     return TRUE;
 }
@@ -843,15 +858,15 @@ void wxThreadModule::OnExit()
 
     for ( size_t n = 0u; n < count; n++ )
     {
-        gs_allThreads[n]->Delete();
+	// Delete calls the destructor which removes the current entry. We
+	// should only delete the first one each time.
+        gs_allThreads[0]->Delete();
     }
 
-#ifndef __WXGTK12__
     // destroy GUI mutex
     gs_mutexGui->Unlock();
 
     delete gs_mutexGui;
-#endif
 
     // and free TLD slot
     (void)pthread_key_delete(gs_keySelf);
@@ -863,20 +878,12 @@ void wxThreadModule::OnExit()
 
 void wxMutexGuiEnter()
 {
-#ifdef __WXGTK12__
-  gdk_threads_enter();
-#else
   gs_mutexGui->Lock();
-#endif
 }
 
 void wxMutexGuiLeave()
 {
-#ifdef __WXGTK12__
-  gdk_threads_leave();
-#else
   gs_mutexGui->Unlock();
-#endif
 }
 
 #endif