X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/19da43267e410c8acdd57a31d89b6c5ecce8c36f..866592d872daa1f4e3d44948d7d3a6c90b0af9d0:/src/unix/threadpsx.cpp?ds=sidebyside diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp index d7dac9c864..c3a6ff6268 100644 --- a/src/unix/threadpsx.cpp +++ b/src/unix/threadpsx.cpp @@ -47,10 +47,6 @@ #include #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; } @@ -231,6 +226,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(); @@ -272,7 +272,9 @@ private: // state // 2. The Delete() function blocks until the condition is signaled when the // thread exits. - wxMutex m_mutex; + // 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; // another (mutex, cond) pair for Pause()/Resume() usage @@ -289,6 +291,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 ) @@ -297,15 +300,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); @@ -315,6 +325,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; @@ -323,6 +355,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 @@ -336,6 +373,17 @@ wxThreadInternal::~wxThreadInternal() // note that m_mutex will be unlocked by the thread which waits for our // termination + + // 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() @@ -369,11 +417,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() ) @@ -387,13 +438,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() @@ -618,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: @@ -642,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; } @@ -663,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; } @@ -707,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); } @@ -771,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; } @@ -795,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); @@ -815,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