X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/a737331db68b754c8bf31fa0a15f6d1f207b40bf..764a3a49068a94d1edb96f299b10c155d101c1b0:/src/unix/threadpsx.cpp

diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp
index ddb603d172..edd373cdc4 100644
--- a/src/unix/threadpsx.cpp
+++ b/src/unix/threadpsx.cpp
@@ -225,6 +225,11 @@ public:
     // thread entry function
     static void *PthreadStart(void *ptr);
 
+#if HAVE_THREAD_CLEANUP_FUNCTIONS
+    // thread exit function
+    static void PthreadCleanup(void *ptr);
+#endif
+
     // thread actions
         // start the thread
     wxThreadError Run();
@@ -266,7 +271,7 @@ private:
     //     state
     //  2. The Delete() function blocks until the condition is signaled when the
     //     thread exits.
-    wxMutex     m_mutex;
+    wxMutex     m_mutex, m_end_mutex;
     wxCondition m_cond;
 
     // another (mutex, cond) pair for Pause()/Resume() usage
@@ -283,6 +288,7 @@ void *wxThreadInternal::PthreadStart(void *ptr)
 {
     wxThread *thread = (wxThread *)ptr;
     wxThreadInternal *pthread = thread->p_internal;
+    void *status;
 
     int rc = pthread_setspecific(gs_keySelf, thread);
     if ( rc != 0 )
@@ -291,15 +297,22 @@ void *wxThreadInternal::PthreadStart(void *ptr)
 
         return (void *)-1;
     }
+#if HAVE_THREAD_CLEANUP_FUNCTIONS
+    // Install the cleanup handler.
+//    pthread_cleanup_push(wxThreadInternal::PthreadCleanup, ptr);
+#endif
 
     // 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
-    void* status = thread->Entry();
+    status = thread->Entry();
+
+#if HAVE_THREAD_CLEANUP_FUNCTIONS
+//    pthread_cleanup_pop(FALSE);
+#endif
 
     // terminate the thread
     thread->Exit(status);
@@ -309,6 +322,28 @@ void *wxThreadInternal::PthreadStart(void *ptr)
     return NULL;
 }
 
+#if HAVE_THREAD_CLEANUP_FUNCTIONS
+// Only called when the thread is explicitely killed.
+
+void wxThreadInternal::PthreadCleanup(void *ptr)
+{
+    wxThread *thread = (wxThread *) ptr;
+
+    // The thread is already considered as finished.
+    if (thread->p_internal->GetState() == STATE_EXITED)
+      return;
+
+    // first call user-level clean up code
+    thread->OnExit();
+
+    // next wake up the threads waiting for us (OTOH, this function won't retur
+    // until someone waited for us!)
+    thread->p_internal->SetState(STATE_EXITED);
+
+    thread->p_internal->SignalExit();
+}
+#endif
+
 wxThreadInternal::wxThreadInternal()
 {
     m_state = STATE_NEW;
@@ -317,6 +352,11 @@ wxThreadInternal::wxThreadInternal()
     // this mutex is locked during almost all thread lifetime - it will only be
     // 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
     // unless the thread is paused
@@ -330,6 +370,9 @@ wxThreadInternal::~wxThreadInternal()
 
     // note that m_mutex will be unlocked by the thread which waits for our
     // termination
+
+    // m_end_mutex can be unlocked here.
+    m_end_mutex.Unlock();
 }
 
 wxThreadError wxThreadInternal::Run()
@@ -363,11 +406,14 @@ void wxThreadInternal::Wait()
 
     // entering Wait() releases the mutex thus allowing SignalExit() to acquire
     // it and to signal us its termination
-    m_cond.Wait(m_mutex);
+    m_cond.Wait(m_end_mutex);
 
     // mutex is still in the locked state - relocked on exit from Wait(), so
     // unlock it - we don't need it any more, the thread has already terminated
-    m_mutex.Unlock();
+    m_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() )
@@ -381,13 +427,13 @@ void wxThreadInternal::SignalExit()
 
     // as mutex is currently locked, this will block until some other thread
     // (normally the same which created this one) unlocks it by entering Wait()
-    m_mutex.Lock();
+    m_end_mutex.Lock();
 
     // wake up all the threads waiting for our termination
     m_cond.Broadcast();
 
     // after this call mutex will be finally unlocked
-    m_mutex.Unlock();
+    m_end_mutex.Unlock();
 }
 
 void wxThreadInternal::Pause()
@@ -614,11 +660,12 @@ wxThread::ExitCode wxThread::Delete()
 {
     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:
@@ -767,9 +814,8 @@ bool wxThreadModule::OnInit()
 
     gs_mutexGui = new wxMutex();
 
-    //wxThreadGuiInit();
-
     gs_tidMain = pthread_self();
+
     gs_mutexGui->Lock();
 
     return TRUE;
@@ -792,8 +838,6 @@ void wxThreadModule::OnExit()
     // destroy GUI mutex
     gs_mutexGui->Unlock();
 
-    //wxThreadGuiExit();
-
     delete gs_mutexGui;
 
     // and free TLD slot