1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: wxThread (Posix) Implementation
4 // Author: Original from Wolfram Gloger/Guilhem Lavaux
8 // Copyright: (c) Wolfram Gloger (1996, 1997)
9 // Guilhem Lavaux (1998)
10 // Vadim Zeitlin (1999)
11 // Robert Roebling (1999)
12 // Licence: wxWindows licence
13 /////////////////////////////////////////////////////////////////////////////
15 // ============================================================================
17 // ============================================================================
19 // ----------------------------------------------------------------------------
21 // ----------------------------------------------------------------------------
24 #pragma implementation "thread.h"
27 // With simple makefiles, we must ignore the file body if not using
33 #include "wx/thread.h"
34 #include "wx/module.h"
38 #include "wx/dynarray.h"
50 // ----------------------------------------------------------------------------
52 // ----------------------------------------------------------------------------
54 // the possible states of the thread and transitions from them
57 STATE_NEW
, // didn't start execution yet (=> RUNNING)
58 STATE_RUNNING
, // running (=> PAUSED or EXITED)
59 STATE_PAUSED
, // suspended (=> RUNNING or EXITED)
60 STATE_EXITED
// thread doesn't exist any more
63 // ----------------------------------------------------------------------------
65 // ----------------------------------------------------------------------------
67 WX_DEFINE_ARRAY(wxThread
*, wxArrayThread
);
69 // -----------------------------------------------------------------------------
71 // -----------------------------------------------------------------------------
73 // we keep the list of all threads created by the application to be able to
74 // terminate them on exit if there are some left - otherwise the process would
76 static wxArrayThread gs_allThreads
;
78 // the id of the main thread
79 static pthread_t gs_tidMain
;
81 // the key for the pointer to the associated wxThread object
82 static pthread_key_t gs_keySelf
;
84 // this mutex must be acquired before any call to a GUI function
85 static wxMutex
*gs_mutexGui
;
87 // ============================================================================
89 // ============================================================================
91 //--------------------------------------------------------------------
92 // wxMutex (Posix implementation)
93 //--------------------------------------------------------------------
98 pthread_mutex_t p_mutex
;
103 p_internal
= new wxMutexInternal
;
105 pthread_mutex_init( &(p_internal
->p_mutex
), (const pthread_mutexattr_t
*) NULL
);
112 wxLogDebug(T("Freeing a locked mutex (%d locks)"), m_locked
);
114 pthread_mutex_destroy( &(p_internal
->p_mutex
) );
118 wxMutexError
wxMutex::Lock()
120 int err
= pthread_mutex_lock( &(p_internal
->p_mutex
) );
123 wxLogDebug(T("Locking this mutex would lead to deadlock!"));
125 return wxMUTEX_DEAD_LOCK
;
130 return wxMUTEX_NO_ERROR
;
133 wxMutexError
wxMutex::TryLock()
140 int err
= pthread_mutex_trylock( &(p_internal
->p_mutex
) );
143 case EBUSY
: return wxMUTEX_BUSY
;
148 return wxMUTEX_NO_ERROR
;
151 wxMutexError
wxMutex::Unlock()
159 wxLogDebug(T("Unlocking not locked mutex."));
161 return wxMUTEX_UNLOCKED
;
164 pthread_mutex_unlock( &(p_internal
->p_mutex
) );
166 return wxMUTEX_NO_ERROR
;
169 //--------------------------------------------------------------------
170 // wxCondition (Posix implementation)
171 //--------------------------------------------------------------------
173 class wxConditionInternal
176 pthread_cond_t p_condition
;
179 wxCondition::wxCondition()
181 p_internal
= new wxConditionInternal
;
182 pthread_cond_init( &(p_internal
->p_condition
), (const pthread_condattr_t
*) NULL
);
185 wxCondition::~wxCondition()
187 pthread_cond_destroy( &(p_internal
->p_condition
) );
192 void wxCondition::Wait(wxMutex
& mutex
)
194 pthread_cond_wait( &(p_internal
->p_condition
), &(mutex
.p_internal
->p_mutex
) );
197 bool wxCondition::Wait(wxMutex
& mutex
, unsigned long sec
, unsigned long nsec
)
199 struct timespec tspec
;
201 tspec
.tv_sec
= time(0L)+sec
;
202 tspec
.tv_nsec
= nsec
;
203 return (pthread_cond_timedwait(&(p_internal
->p_condition
), &(mutex
.p_internal
->p_mutex
), &tspec
) != ETIMEDOUT
);
206 void wxCondition::Signal()
208 pthread_cond_signal( &(p_internal
->p_condition
) );
211 void wxCondition::Broadcast()
213 pthread_cond_broadcast( &(p_internal
->p_condition
) );
216 //--------------------------------------------------------------------
217 // wxThread (Posix implementation)
218 //--------------------------------------------------------------------
220 class wxThreadInternal
226 // thread entry function
227 static void *PthreadStart(void *ptr
);
229 #if HAVE_THREAD_CLEANUP_FUNCTIONS
230 // thread exit function
231 static void PthreadCleanup(void *ptr
);
237 // ask the thread to terminate
239 // wake up threads waiting for our termination
241 // go to sleep until Resume() is called
248 int GetPriority() const { return m_prio
; }
249 void SetPriority(int prio
) { m_prio
= prio
; }
251 wxThreadState
GetState() const { return m_state
; }
252 void SetState(wxThreadState state
) { m_state
= state
; }
254 pthread_t
GetId() const { return m_threadId
; }
255 pthread_t
*GetIdPtr() { return &m_threadId
; }
257 void SetCancelFlag() { m_cancelled
= TRUE
; }
258 bool WasCancelled() const { return m_cancelled
; }
261 pthread_t m_threadId
; // id of the thread
262 wxThreadState m_state
; // see wxThreadState enum
263 int m_prio
; // in wxWindows units: from 0 to 100
265 // set when the thread should terminate
268 // this (mutex, cond) pair is used to synchronize the main thread and this
269 // thread in several situations:
270 // 1. The thread function blocks until condition is signaled by Run() when
271 // it's initially created - this allows thread creation in "suspended"
273 // 2. The Delete() function blocks until the condition is signaled when the
275 // GL: On Linux, this may fail because we can have a deadlock in either
276 // SignalExit() or Wait(): so we add m_end_mutex for the finalization.
277 wxMutex m_mutex
, m_end_mutex
;
280 // another (mutex, cond) pair for Pause()/Resume() usage
282 // VZ: it's possible that we might reuse the mutex and condition from above
283 // for this too, but as I'm not at all sure that it won't create subtle
284 // problems with race conditions between, say, Pause() and Delete() I
285 // prefer this may be a bit less efficient but much safer solution
286 wxMutex m_mutexSuspend
;
287 wxCondition m_condSuspend
;
290 void *wxThreadInternal::PthreadStart(void *ptr
)
292 wxThread
*thread
= (wxThread
*)ptr
;
293 wxThreadInternal
*pthread
= thread
->p_internal
;
296 int rc
= pthread_setspecific(gs_keySelf
, thread
);
299 wxLogSysError(rc
, _("Cannot start thread: error writing TLS"));
303 #if HAVE_THREAD_CLEANUP_FUNCTIONS
304 // Install the cleanup handler.
305 pthread_cleanup_push(wxThreadInternal::PthreadCleanup
, ptr
);
308 // wait for the condition to be signaled from Run()
309 // mutex state: currently locked by the thread which created us
310 pthread
->m_cond
.Wait(pthread
->m_mutex
);
311 // mutex state: locked again on exit of Wait()
313 // call the main entry
314 status
= thread
->Entry();
316 #if HAVE_THREAD_CLEANUP_FUNCTIONS
317 pthread_cleanup_pop(FALSE
);
320 // terminate the thread
321 thread
->Exit(status
);
323 wxFAIL_MSG(T("wxThread::Exit() can't return."));
328 #if HAVE_THREAD_CLEANUP_FUNCTIONS
329 // Only called when the thread is explicitely killed.
331 void wxThreadInternal::PthreadCleanup(void *ptr
)
333 wxThread
*thread
= (wxThread
*) ptr
;
335 // The thread is already considered as finished.
336 if (thread
->p_internal
->GetState() == STATE_EXITED
)
339 // first call user-level clean up code
342 // next wake up the threads waiting for us (OTOH, this function won't retur
343 // until someone waited for us!)
344 thread
->p_internal
->SetState(STATE_EXITED
);
346 thread
->p_internal
->SignalExit();
350 wxThreadInternal::wxThreadInternal()
355 // this mutex is locked during almost all thread lifetime - it will only be
356 // unlocked in the very end
359 // this mutex is used by wxThreadInternal::Wait() and by
360 // wxThreadInternal::SignalExit(). We don't use m_mutex because of a
361 // possible deadlock in either Wait() or SignalExit().
364 // this mutex is used in Pause()/Resume() and is also locked all the time
365 // unless the thread is paused
366 m_mutexSuspend
.Lock();
369 wxThreadInternal::~wxThreadInternal()
371 // GL: moved to SignalExit
372 // m_mutexSuspend.Unlock();
374 // note that m_mutex will be unlocked by the thread which waits for our
377 // In the case, we didn't start the thread, all these mutex are locked:
378 // we must unlock them.
379 if (m_mutex
.IsLocked())
382 if (m_end_mutex
.IsLocked())
383 m_end_mutex
.Unlock();
385 if (m_mutexSuspend
.IsLocked())
386 m_mutexSuspend
.Unlock();
389 wxThreadError
wxThreadInternal::Run()
391 wxCHECK_MSG( GetState() == STATE_NEW
, wxTHREAD_RUNNING
,
392 T("thread may only be started once after successful Create()") );
394 // the mutex was locked on Create(), so we will be able to lock it again
395 // only when the thread really starts executing and enters the wait -
396 // otherwise we might signal the condition before anybody is waiting for it
397 wxMutexLocker
lock(m_mutex
);
400 m_state
= STATE_RUNNING
;
402 return wxTHREAD_NO_ERROR
;
404 // now the mutex is unlocked back - but just to allow Wait() function to
405 // terminate by relocking it, so the net result is that the worker thread
406 // starts executing and the mutex is still locked
409 void wxThreadInternal::Wait()
411 wxCHECK_RET( WasCancelled(), T("thread should have been cancelled first") );
413 // if the thread we're waiting for is waiting for the GUI mutex, we will
414 // deadlock so make sure we release it temporarily
415 if ( wxThread::IsMain() )
418 // entering Wait() releases the mutex thus allowing SignalExit() to acquire
419 // it and to signal us its termination
420 m_cond
.Wait(m_end_mutex
);
422 // mutex is still in the locked state - relocked on exit from Wait(), so
423 // unlock it - we don't need it any more, the thread has already terminated
424 m_end_mutex
.Unlock();
426 // After that, we wait for the real end of the other thread.
427 pthread_join(GetId(), NULL
);
429 // reacquire GUI mutex
430 if ( wxThread::IsMain() )
434 void wxThreadInternal::SignalExit()
436 // GL: Unlock mutexSuspend here.
437 m_mutexSuspend
.Unlock();
439 // as mutex is currently locked, this will block until some other thread
440 // (normally the same which created this one) unlocks it by entering Wait()
443 // wake up all the threads waiting for our termination
446 // after this call mutex will be finally unlocked
447 m_end_mutex
.Unlock();
450 void wxThreadInternal::Pause()
452 // the state is set from the thread which pauses us first, this function
453 // is called later so the state should have been already set
454 wxCHECK_RET( m_state
== STATE_PAUSED
,
455 T("thread must first be paused with wxThread::Pause().") );
457 // don't pause the thread which is being terminated - this would lead to
458 // deadlock if the thread is paused after Delete() had called Resume() but
459 // before it had time to call Wait()
460 if ( WasCancelled() )
463 // wait until the condition is signaled from Resume()
464 m_condSuspend
.Wait(m_mutexSuspend
);
467 void wxThreadInternal::Resume()
469 wxCHECK_RET( m_state
== STATE_PAUSED
,
470 T("can't resume thread which is not suspended.") );
472 // we will be able to lock this mutex only when Pause() starts waiting
473 wxMutexLocker
lock(m_mutexSuspend
);
474 m_condSuspend
.Signal();
476 SetState(STATE_RUNNING
);
479 // -----------------------------------------------------------------------------
481 // -----------------------------------------------------------------------------
483 wxThread
*wxThread::This()
485 return (wxThread
*)pthread_getspecific(gs_keySelf
);
488 bool wxThread::IsMain()
490 return (bool)pthread_equal(pthread_self(), gs_tidMain
);
493 void wxThread::Yield()
498 void wxThread::Sleep(unsigned long milliseconds
)
500 wxUsleep(milliseconds
);
503 // -----------------------------------------------------------------------------
505 // -----------------------------------------------------------------------------
509 // add this thread to the global list of all threads
510 gs_allThreads
.Add(this);
512 p_internal
= new wxThreadInternal();
515 wxThreadError
wxThread::Create()
517 if (p_internal
->GetState() != STATE_NEW
)
518 return wxTHREAD_RUNNING
;
520 // set up the thread attribute: right now, we only set thread priority
522 pthread_attr_init(&attr
);
524 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
526 if ( pthread_attr_getschedpolicy(&attr
, &prio
) != 0 )
528 wxLogError(_("Cannot retrieve thread scheduling policy."));
531 int min_prio
= sched_get_priority_min(prio
),
532 max_prio
= sched_get_priority_max(prio
);
534 if ( min_prio
== -1 || max_prio
== -1 )
536 wxLogError(_("Cannot get priority range for scheduling policy %d."),
541 struct sched_param sp
;
542 pthread_attr_getschedparam(&attr
, &sp
);
543 sp
.sched_priority
= min_prio
+
544 (p_internal
->GetPriority()*(max_prio
-min_prio
))/100;
545 pthread_attr_setschedparam(&attr
, &sp
);
547 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS
549 #ifdef HAVE_PTHREAD_ATTR_SETSCOPE
550 // this will make the threads created by this process really concurrent
551 pthread_attr_setscope(&attr
, PTHREAD_SCOPE_SYSTEM
);
552 #endif // HAVE_PTHREAD_ATTR_SETSCOPE
554 // create the new OS thread object
555 int rc
= pthread_create(p_internal
->GetIdPtr(), &attr
,
556 wxThreadInternal::PthreadStart
, (void *)this);
557 pthread_attr_destroy(&attr
);
561 p_internal
->SetState(STATE_EXITED
);
562 return wxTHREAD_NO_RESOURCE
;
565 return wxTHREAD_NO_ERROR
;
568 wxThreadError
wxThread::Run()
570 return p_internal
->Run();
573 // -----------------------------------------------------------------------------
575 // -----------------------------------------------------------------------------
577 void wxThread::SetPriority(unsigned int prio
)
579 wxCHECK_RET( ((int)WXTHREAD_MIN_PRIORITY
<= (int)prio
) &&
580 ((int)prio
<= (int)WXTHREAD_MAX_PRIORITY
),
581 T("invalid thread priority") );
583 wxCriticalSectionLocker
lock(m_critsect
);
585 switch ( p_internal
->GetState() )
588 // thread not yet started, priority will be set when it is
589 p_internal
->SetPriority(prio
);
594 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
596 struct sched_param sparam
;
597 sparam
.sched_priority
= prio
;
599 if ( pthread_setschedparam(p_internal
->GetId(),
600 SCHED_OTHER
, &sparam
) != 0 )
602 wxLogError(_("Failed to set thread priority %d."), prio
);
605 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS
610 wxFAIL_MSG(T("impossible to set thread priority in this state"));
614 unsigned int wxThread::GetPriority() const
616 wxCriticalSectionLocker
lock((wxCriticalSection
&)m_critsect
);
618 return p_internal
->GetPriority();
621 unsigned long wxThread::GetID() const
623 return (unsigned long)p_internal
->GetId();
626 // -----------------------------------------------------------------------------
628 // -----------------------------------------------------------------------------
630 wxThreadError
wxThread::Pause()
632 wxCriticalSectionLocker
lock(m_critsect
);
634 if ( p_internal
->GetState() != STATE_RUNNING
)
636 wxLogDebug(T("Can't pause thread which is not running."));
638 return wxTHREAD_NOT_RUNNING
;
641 p_internal
->SetState(STATE_PAUSED
);
643 return wxTHREAD_NO_ERROR
;
646 wxThreadError
wxThread::Resume()
648 wxCriticalSectionLocker
lock(m_critsect
);
650 if ( p_internal
->GetState() == STATE_PAUSED
)
653 p_internal
->Resume();
656 return wxTHREAD_NO_ERROR
;
660 wxLogDebug(T("Attempt to resume a thread which is not paused."));
662 return wxTHREAD_MISC_ERROR
;
666 // -----------------------------------------------------------------------------
668 // -----------------------------------------------------------------------------
670 wxThread::ExitCode
wxThread::Delete()
676 wxThreadState state
= p_internal
->GetState();
678 // ask the thread to stop
679 p_internal
->SetCancelFlag();
691 // resume the thread first
697 // wait until the thread stops
700 //GL: As we must auto-destroy, the destruction must happen here.
706 wxThreadError
wxThread::Kill()
708 switch ( p_internal
->GetState() )
712 return wxTHREAD_NOT_RUNNING
;
715 #ifdef HAVE_PTHREAD_CANCEL
716 if ( pthread_cancel(p_internal
->GetId()) != 0 )
719 wxLogError(_("Failed to terminate a thread."));
721 return wxTHREAD_MISC_ERROR
;
723 //GL: As we must auto-destroy, the destruction must happen here (2).
726 return wxTHREAD_NO_ERROR
;
730 void wxThread::Exit(void *status
)
732 // first call user-level clean up code
735 // next wake up the threads waiting for us (OTOH, this function won't return
736 // until someone waited for us!)
737 p_internal
->SignalExit();
739 p_internal
->SetState(STATE_EXITED
);
741 // delete both C++ thread object and terminate the OS thread object
742 // GL: This is very ugly and buggy ...
744 pthread_exit(status
);
747 // also test whether we were paused
748 bool wxThread::TestDestroy()
750 wxCriticalSectionLocker
lock(m_critsect
);
752 if ( p_internal
->GetState() == STATE_PAUSED
)
754 // leave the crit section or the other threads will stop too if they try
755 // to call any of (seemingly harmless) IsXXX() functions while we sleep
760 // enter it back before it's finally left in lock object dtor
764 return p_internal
->WasCancelled();
767 wxThread::~wxThread()
770 if (p_internal
->GetState() != STATE_EXITED
&&
771 p_internal
->GetState() != STATE_NEW
)
772 wxLogDebug(T("The thread is being destroyed althought it is still running ! The application may crash."));
777 // remove this thread from the global array
778 gs_allThreads
.Remove(this);
781 // -----------------------------------------------------------------------------
783 // -----------------------------------------------------------------------------
785 bool wxThread::IsRunning() const
787 wxCriticalSectionLocker
lock((wxCriticalSection
&)m_critsect
);
789 return p_internal
->GetState() == STATE_RUNNING
;
792 bool wxThread::IsAlive() const
794 wxCriticalSectionLocker
lock((wxCriticalSection
&)m_critsect
);
796 switch ( p_internal
->GetState() )
807 bool wxThread::IsPaused() const
809 wxCriticalSectionLocker
lock((wxCriticalSection
&)m_critsect
);
811 return (p_internal
->GetState() == STATE_PAUSED
);
814 //--------------------------------------------------------------------
816 //--------------------------------------------------------------------
818 class wxThreadModule
: public wxModule
821 virtual bool OnInit();
822 virtual void OnExit();
825 DECLARE_DYNAMIC_CLASS(wxThreadModule
)
828 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule
, wxModule
)
830 bool wxThreadModule::OnInit()
832 int rc
= pthread_key_create(&gs_keySelf
, NULL
/* dtor function */);
835 wxLogSysError(rc
, _("Thread module initialization failed: "
836 "failed to create thread key"));
841 gs_mutexGui
= new wxMutex();
843 gs_tidMain
= pthread_self();
850 void wxThreadModule::OnExit()
852 wxASSERT_MSG( wxThread::IsMain(), T("only main thread can be here") );
854 // terminate any threads left
855 size_t count
= gs_allThreads
.GetCount();
857 wxLogDebug(T("Some threads were not terminated by the application."));
859 for ( size_t n
= 0u; n
< count
; n
++ )
861 // Delete calls the destructor which removes the current entry. We
862 // should only delete the first one each time.
863 gs_allThreads
[0]->Delete();
867 gs_mutexGui
->Unlock();
872 (void)pthread_key_delete(gs_keySelf
);
875 // ----------------------------------------------------------------------------
877 // ----------------------------------------------------------------------------
879 void wxMutexGuiEnter()
884 void wxMutexGuiLeave()
886 gs_mutexGui
->Unlock();