wxMutex::wxMutex()
{
p_internal = new wxMutexInternal;
+
pthread_mutex_init( &(p_internal->p_mutex), (const pthread_mutexattr_t*) NULL );
m_locked = 0;
}
wxMutex::~wxMutex()
{
if (m_locked > 0)
- wxLogDebug(_T("Freeing a locked mutex (%d locks)"), m_locked);
+ wxLogDebug(wxT("Freeing a locked mutex (%d locks)"), m_locked);
pthread_mutex_destroy( &(p_internal->p_mutex) );
delete p_internal;
int err = pthread_mutex_lock( &(p_internal->p_mutex) );
if (err == EDEADLK)
{
- wxLogDebug(_T("Locking this mutex would lead to deadlock!"));
+ wxLogDebug(wxT("Locking this mutex would lead to deadlock!"));
return wxMUTEX_DEAD_LOCK;
}
}
else
{
- wxLogDebug(_T("Unlocking not locked mutex."));
+ wxLogDebug(wxT("Unlocking not locked mutex."));
return wxMUTEX_UNLOCKED;
}
// 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;
}
#if HAVE_THREAD_CLEANUP_FUNCTIONS
// Install the cleanup handler.
-// pthread_cleanup_push(wxThreadInternal::PthreadCleanup, ptr);
+ pthread_cleanup_push(wxThreadInternal::PthreadCleanup, ptr);
#endif
// wait for the condition to be signaled from Run()
status = thread->Entry();
#if HAVE_THREAD_CLEANUP_FUNCTIONS
-// pthread_cleanup_pop(FALSE);
+ pthread_cleanup_pop(FALSE);
#endif
// terminate the thread
thread->Exit(status);
- wxFAIL_MSG(_T("wxThread::Exit() can't return."));
+ wxFAIL_MSG(wxT("wxThread::Exit() can't return."));
return NULL;
}
{
m_state = STATE_NEW;
m_cancelled = FALSE;
+ m_prio = WXTHREAD_DEFAULT_PRIORITY;
+ m_threadId = 0;
// this mutex is locked during almost all thread lifetime - it will only be
// unlocked in the very end
// 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();
+ // 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()
{
wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
- _T("thread may only be started once after successful Create()") );
+ wxT("thread may only be started once after successful Create()") );
// the mutex was locked on Create(), so we will be able to lock it again
// only when the thread really starts executing and enters the wait -
void wxThreadInternal::Wait()
{
- wxCHECK_RET( WasCancelled(), _T("thread should have been cancelled first") );
+ wxCHECK_RET( WasCancelled(), wxT("thread should have been cancelled first") );
// if the thread we're waiting for is waiting for the GUI mutex, we will
// deadlock so make sure we release it temporarily
// the state is set from the thread which pauses us first, this function
// is called later so the state should have been already set
wxCHECK_RET( m_state == STATE_PAUSED,
- _T("thread must first be paused with wxThread::Pause().") );
+ wxT("thread must first be paused with wxThread::Pause().") );
// don't pause the thread which is being terminated - this would lead to
// deadlock if the thread is paused after Delete() had called Resume() but
void wxThreadInternal::Resume()
{
wxCHECK_RET( m_state == STATE_PAUSED,
- _T("can't resume thread which is not suspended.") );
+ wxT("can't resume thread which is not suspended.") );
// we will be able to lock this mutex only when Pause() starts waiting
wxMutexLocker lock(m_mutexSuspend);
wxLogError(_("Cannot get priority range for scheduling policy %d."),
prio);
}
+ else if ( max_prio == min_prio )
+ {
+ if ( p_internal->GetPriority() != WXTHREAD_DEFAULT_PRIORITY )
+ {
+ // notify the programmer that this doesn't work here
+ wxLogWarning(_("Thread priority setting is ignored."));
+ }
+ //else: we have default priority, so don't complain
+
+ // anyhow, don't do anything because priority is just ignored
+ }
else
{
struct sched_param sp;
wxThreadError wxThread::Run()
{
+ wxCHECK_MSG( p_internal->GetId(), wxTHREAD_MISC_ERROR,
+ wxT("must call wxThread::Create() first") );
+
return p_internal->Run();
}
{
wxCHECK_RET( ((int)WXTHREAD_MIN_PRIORITY <= (int)prio) &&
((int)prio <= (int)WXTHREAD_MAX_PRIORITY),
- _T("invalid thread priority") );
+ wxT("invalid thread priority") );
wxCriticalSectionLocker lock(m_critsect);
case STATE_EXITED:
default:
- wxFAIL_MSG(_T("impossible to set thread priority in this state"));
+ wxFAIL_MSG(wxT("impossible to set thread priority in this state"));
}
}
if ( p_internal->GetState() != STATE_RUNNING )
{
- wxLogDebug(_T("Can't pause thread which is not running."));
+ wxLogDebug(wxT("Can't pause thread which is not running."));
return wxTHREAD_NOT_RUNNING;
}
}
else
{
- wxLogDebug(_T("Attempt to resume a thread which is not paused."));
+ wxLogDebug(wxT("Attempt to resume a thread which is not paused."));
return wxTHREAD_MISC_ERROR;
}
wxThread::ExitCode wxThread::Delete()
{
+ if (IsPaused())
+ Resume();
+
m_critsect.Enter();
wxThreadState state = p_internal->GetState();
// 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;
}
wxThread::~wxThread()
{
+ m_critsect.Enter();
+ if ( p_internal->GetState() != STATE_EXITED &&
+ p_internal->GetState() != STATE_NEW )
+ {
+ wxLogDebug(wxT("The thread is being destroyed although 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);
}
void wxThreadModule::OnExit()
{
- wxASSERT_MSG( wxThread::IsMain(), _T("only main thread can be here") );
+ wxASSERT_MSG( wxThread::IsMain(), wxT("only main thread can be here") );
// terminate any threads left
size_t count = gs_allThreads.GetCount();
if ( count != 0u )
- wxLogDebug(_T("Some threads were not terminated by the application."));
+ wxLogDebug(wxT("Some threads were not terminated by the application."));
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();
}
// destroy GUI mutex
projects / wxWidgets.git / blobdiff