#include <sched.h>
#endif
-#ifdef __WXGTK12__
-#include "gtk/gtk.h"
-#endif
-
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
// 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
wxMutex::wxMutex()
{
p_internal = new wxMutexInternal;
+
pthread_mutex_init( &(p_internal->p_mutex), (const pthread_mutexattr_t*) NULL );
m_locked = 0;
}
// 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;
// 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
// 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
// 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()
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();
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()
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:
// wait until the thread stops
p_internal->Wait();
}
+ //GL: As we must auto-destroy, the destruction must happen here.
+ delete this;
return NULL;
}
return wxTHREAD_MISC_ERROR;
}
+ //GL: As we must auto-destroy, the destruction must happen here (2).
+ delete this;
return wxTHREAD_NO_ERROR;
}
{
// 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);
}
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);
}
return FALSE;
}
-#ifndef __WXGTK12__
gs_mutexGui = new wxMutex();
-#endif
gs_tidMain = pthread_self();
-#ifndef __WXGTK12__
gs_mutexGui->Lock();
-#endif
return TRUE;
}
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);
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
projects / wxWidgets.git / blobdiff