1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: wxThread Implementation
4 // Author: Original from Wolfram Gloger/Guilhem Lavaux
5 // Modified by: Vadim Zeitlin to make it work :-)
8 // Copyright: (c) Wolfram Gloger (1996, 1997); Guilhem Lavaux (1998),
9 // Vadim Zeitlin (1999)
10 // Licence: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
14 #pragma implementation "thread.h"
17 // ----------------------------------------------------------------------------
19 // ----------------------------------------------------------------------------
21 // For compilers that support precompilation, includes "wx.h".
22 #include "wx/wxprec.h"
24 #if defined(__BORLANDC__)
38 #include "wx/module.h"
39 #include "wx/thread.h"
41 // the possible states of the thread ("=>" shows all possible transitions from
45 STATE_NEW
, // didn't start execution yet (=> RUNNING)
46 STATE_RUNNING
, // thread is running (=> PAUSED, CANCELED)
47 STATE_PAUSED
, // thread is temporarily suspended (=> RUNNING)
48 STATE_CANCELED
, // thread should terminate a.s.a.p. (=> EXITED)
49 STATE_EXITED
// thread is terminating
52 // ----------------------------------------------------------------------------
54 // ----------------------------------------------------------------------------
56 // TLS index of the slot where we store the pointer to the current thread
57 static DWORD s_tlsThisThread
= 0xFFFFFFFF;
59 // id of the main thread - the one which can call GUI functions without first
60 // calling wxMutexGuiEnter()
61 static DWORD s_idMainThread
= 0;
63 // if it's FALSE, some secondary thread is holding the GUI lock
64 static bool s_bGuiOwnedByMainThread
= TRUE
;
66 // critical section which controls access to all GUI functions: any secondary
67 // thread (i.e. except the main one) must enter this crit section before doing
69 static wxCriticalSection
*s_critsectGui
= NULL
;
71 // critical section which protects s_nWaitingForGui variable
72 static wxCriticalSection
*s_critsectWaitingForGui
= NULL
;
74 // number of threads waiting for GUI in wxMutexGuiEnter()
75 static size_t s_nWaitingForGui
= 0;
77 // are we waiting for a thread termination?
78 static bool s_waitingForThread
= FALSE
;
80 // ============================================================================
81 // Windows implementation of thread classes
82 // ============================================================================
84 // ----------------------------------------------------------------------------
85 // wxMutex implementation
86 // ----------------------------------------------------------------------------
95 p_internal
= new wxMutexInternal
;
96 p_internal
->p_mutex
= CreateMutex(NULL
, FALSE
, NULL
);
97 if ( !p_internal
->p_mutex
)
99 wxLogSysError(_("Can not create mutex."));
108 wxLogDebug("Warning: freeing a locked mutex (%d locks).", m_locked
);
109 CloseHandle(p_internal
->p_mutex
);
112 wxMutexError
wxMutex::Lock()
116 ret
= WaitForSingleObject(p_internal
->p_mutex
, INFINITE
);
127 wxLogSysError(_("Couldn't acquire a mutex lock"));
128 return wxMUTEX_MISC_ERROR
;
132 wxFAIL_MSG("impossible return value in wxMutex::Lock");
136 return wxMUTEX_NO_ERROR
;
139 wxMutexError
wxMutex::TryLock()
143 ret
= WaitForSingleObject(p_internal
->p_mutex
, 0);
144 if (ret
== WAIT_TIMEOUT
|| ret
== WAIT_ABANDONED
)
148 return wxMUTEX_NO_ERROR
;
151 wxMutexError
wxMutex::Unlock()
156 BOOL ret
= ReleaseMutex(p_internal
->p_mutex
);
159 wxLogSysError(_("Couldn't release a mutex"));
160 return wxMUTEX_MISC_ERROR
;
163 return wxMUTEX_NO_ERROR
;
166 // ----------------------------------------------------------------------------
167 // wxCondition implementation
168 // ----------------------------------------------------------------------------
170 class wxConditionInternal
177 wxCondition::wxCondition()
179 p_internal
= new wxConditionInternal
;
180 p_internal
->event
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
181 if ( !p_internal
->event
)
183 wxLogSysError(_("Can not create event object."));
186 p_internal
->waiters
= 0;
189 wxCondition::~wxCondition()
191 CloseHandle(p_internal
->event
);
194 void wxCondition::Wait(wxMutex
& mutex
)
197 p_internal
->waiters
++;
198 WaitForSingleObject(p_internal
->event
, INFINITE
);
199 p_internal
->waiters
--;
203 bool wxCondition::Wait(wxMutex
& mutex
,
210 p_internal
->waiters
++;
211 ret
= WaitForSingleObject(p_internal
->event
, (sec
*1000)+(nsec
/1000000));
212 p_internal
->waiters
--;
215 return (ret
!= WAIT_TIMEOUT
);
218 void wxCondition::Signal()
220 SetEvent(p_internal
->event
);
223 void wxCondition::Broadcast()
227 for (i
=0;i
<p_internal
->waiters
;i
++)
229 if ( SetEvent(p_internal
->event
) == 0 )
231 wxLogSysError(_("Couldn't change the state of event object."));
236 // ----------------------------------------------------------------------------
237 // wxCriticalSection implementation
238 // ----------------------------------------------------------------------------
240 class wxCriticalSectionInternal
243 // init the critical section object
244 wxCriticalSectionInternal()
245 { ::InitializeCriticalSection(&m_data
); }
247 // implicit cast to the associated data
248 operator CRITICAL_SECTION
*() { return &m_data
; }
250 // free the associated ressources
251 ~wxCriticalSectionInternal()
252 { ::DeleteCriticalSection(&m_data
); }
255 CRITICAL_SECTION m_data
;
258 wxCriticalSection::wxCriticalSection()
263 wxCriticalSection::~wxCriticalSection()
269 void wxCriticalSection::Enter()
271 m_critsect
= new wxCriticalSectionInternal
;
273 ::EnterCriticalSection(*m_critsect
);
276 void wxCriticalSection::Leave()
278 wxCHECK_RET( m_critsect
, "Leave() without matching Enter()" );
280 ::LeaveCriticalSection(*m_critsect
);
283 // ----------------------------------------------------------------------------
284 // wxThread implementation
285 // ----------------------------------------------------------------------------
287 // wxThreadInternal class
288 // ----------------------
290 class wxThreadInternal
297 m_priority
= WXTHREAD_DEFAULT_PRIORITY
;
300 // create a new (suspended) thread (for the given thread object)
301 bool Create(wxThread
*thread
);
303 // suspend/resume/terminate
306 void Cancel() { m_state
= STATE_CANCELED
; }
309 void SetState(wxThreadState state
) { m_state
= state
; }
310 wxThreadState
GetState() const { return m_state
; }
313 void SetPriority(unsigned int priority
) { m_priority
= priority
; }
314 unsigned int GetPriority() const { return m_priority
; }
316 // thread handle and id
317 HANDLE
GetHandle() const { return m_hThread
; }
318 DWORD
GetId() const { return m_tid
; }
321 static DWORD
WinThreadStart(wxThread
*thread
);
324 HANDLE m_hThread
; // handle of the thread
325 wxThreadState m_state
; // state, see wxThreadState enum
326 unsigned int m_priority
; // thread priority in "wx" units
327 DWORD m_tid
; // thread id
330 DWORD
wxThreadInternal::WinThreadStart(wxThread
*thread
)
332 // store the thread object in the TLS
333 if ( !::TlsSetValue(s_tlsThisThread
, thread
) )
335 wxLogSysError(_("Can not start thread: error writing TLS."));
340 DWORD ret
= (DWORD
)thread
->Entry();
341 thread
->p_internal
->SetState(STATE_EXITED
);
349 bool wxThreadInternal::Create(wxThread
*thread
)
351 m_hThread
= ::CreateThread
353 NULL
, // default security
354 0, // default stack size
355 (LPTHREAD_START_ROUTINE
) // thread entry point
356 wxThreadInternal::WinThreadStart
, //
357 (LPVOID
)thread
, // parameter
358 CREATE_SUSPENDED
, // flags
359 &m_tid
// [out] thread id
362 if ( m_hThread
== NULL
)
364 wxLogSysError(_("Can't create thread"));
369 // translate wxWindows priority to the Windows one
371 if (m_priority
<= 20)
372 win_priority
= THREAD_PRIORITY_LOWEST
;
373 else if (m_priority
<= 40)
374 win_priority
= THREAD_PRIORITY_BELOW_NORMAL
;
375 else if (m_priority
<= 60)
376 win_priority
= THREAD_PRIORITY_NORMAL
;
377 else if (m_priority
<= 80)
378 win_priority
= THREAD_PRIORITY_ABOVE_NORMAL
;
379 else if (m_priority
<= 100)
380 win_priority
= THREAD_PRIORITY_HIGHEST
;
383 wxFAIL_MSG("invalid value of thread priority parameter");
384 win_priority
= THREAD_PRIORITY_NORMAL
;
387 if ( ::SetThreadPriority(m_hThread
, win_priority
) == 0 )
389 wxLogSysError(_("Can't set thread priority"));
395 bool wxThreadInternal::Suspend()
397 DWORD nSuspendCount
= ::SuspendThread(m_hThread
);
398 if ( nSuspendCount
== (DWORD
)-1 )
400 wxLogSysError(_("Can not suspend thread %x"), m_hThread
);
405 m_state
= STATE_PAUSED
;
410 bool wxThreadInternal::Resume()
412 DWORD nSuspendCount
= ::ResumeThread(m_hThread
);
413 if ( nSuspendCount
== (DWORD
)-1 )
415 wxLogSysError(_("Can not resume thread %x"), m_hThread
);
420 m_state
= STATE_RUNNING
;
428 wxThread
*wxThread::This()
430 wxThread
*thread
= (wxThread
*)::TlsGetValue(s_tlsThisThread
);
432 // be careful, 0 may be a valid return value as well
433 if ( !thread
&& (::GetLastError() != NO_ERROR
) )
435 wxLogSysError(_("Couldn't get the current thread pointer"));
443 bool wxThread::IsMain()
445 return ::GetCurrentThreadId() == s_idMainThread
;
448 void wxThread::Yield()
450 // 0 argument to Sleep() is special
454 void wxThread::Sleep(unsigned long milliseconds
)
456 ::Sleep(milliseconds
);
459 // create/start thread
460 // -------------------
462 wxThreadError
wxThread::Create()
464 if ( !p_internal
->Create(this) )
465 return wxTHREAD_NO_RESOURCE
;
467 return wxTHREAD_NO_ERROR
;
470 wxThreadError
wxThread::Run()
472 wxCriticalSectionLocker
lock(m_critsect
);
474 if ( p_internal
->GetState() != STATE_NEW
)
476 // actually, it may be almost any state at all, not only STATE_RUNNING
477 return wxTHREAD_RUNNING
;
483 // suspend/resume thread
484 // ---------------------
486 wxThreadError
wxThread::Pause()
488 wxCriticalSectionLocker
lock(m_critsect
);
490 return p_internal
->Suspend() ? wxTHREAD_NO_ERROR
: wxTHREAD_MISC_ERROR
;
493 wxThreadError
wxThread::Resume()
495 wxCriticalSectionLocker
lock(m_critsect
);
497 return p_internal
->Resume() ? wxTHREAD_NO_ERROR
: wxTHREAD_MISC_ERROR
;
503 wxThread::ExitCode
wxThread::Delete()
507 // Delete() is always safe to call, so consider all possible states
515 // set flag for wxIsWaitingForThread()
516 s_waitingForThread
= TRUE
;
523 wxCriticalSectionLocker
lock(m_critsect
);
525 p_internal
->Cancel();
526 hThread
= p_internal
->GetHandle();
529 // we can't just wait for the thread to terminate because it might be
530 // calling some GUI functions and so it will never terminate before we
531 // process the Windows messages that result from these functions
535 result
= ::MsgWaitForMultipleObjects
537 1, // number of objects to wait for
538 &hThread
, // the objects
539 FALSE
, // don't wait for all objects
540 INFINITE
, // no timeout
541 QS_ALLEVENTS
// return as soon as there are any events
548 wxLogSysError(_("Can not wait for thread termination"));
553 // thread we're waiting for terminated
556 case WAIT_OBJECT_0
+ 1:
557 // new message arrived, process it
558 if ( !wxTheApp
->DoMessage() )
560 // WM_QUIT received: kill the thread
568 // give the thread we're waiting for chance to exit
569 // from the GUI call it might have been in
570 if ( (s_nWaitingForGui
> 0) && wxGuiOwnedByMainThread() )
579 wxFAIL_MSG("unexpected result of MsgWaitForMultipleObject");
581 } while ( result
!= WAIT_OBJECT_0
);
585 s_waitingForThread
= FALSE
;
590 if ( !::GetExitCodeThread(hThread
, (LPDWORD
)&rc
) )
592 wxLogLastError("GetExitCodeThread");
597 wxASSERT_MSG( (LPVOID
)rc
!= (LPVOID
)STILL_ACTIVE
,
598 "thread must be already terminated." );
600 ::CloseHandle(hThread
);
606 wxThreadError
wxThread::Kill()
609 return wxTHREAD_NOT_RUNNING
;
611 if ( !::TerminateThread(p_internal
->GetHandle(), (DWORD
)-1) )
613 wxLogSysError(_("Couldn't terminate thread"));
615 return wxTHREAD_MISC_ERROR
;
620 return wxTHREAD_NO_ERROR
;
623 void wxThread::Exit(void *status
)
627 ::ExitThread((DWORD
)status
);
629 wxFAIL_MSG("Couldn't return from ExitThread()!");
632 void wxThread::SetPriority(unsigned int prio
)
634 wxCriticalSectionLocker
lock(m_critsect
);
636 p_internal
->SetPriority(prio
);
639 unsigned int wxThread::GetPriority() const
641 wxCriticalSectionLocker
lock((wxCriticalSection
&)m_critsect
);
643 return p_internal
->GetPriority();
646 unsigned long wxThread::GetID() const
648 wxCriticalSectionLocker
lock((wxCriticalSection
&)m_critsect
);
650 return (unsigned long)p_internal
->GetId();
653 bool wxThread::IsRunning() const
655 wxCriticalSectionLocker
lock((wxCriticalSection
&)m_critsect
);
657 return p_internal
->GetState() == STATE_RUNNING
;
660 bool wxThread::IsAlive() const
662 wxCriticalSectionLocker
lock((wxCriticalSection
&)m_critsect
);
664 return (p_internal
->GetState() == STATE_RUNNING
) ||
665 (p_internal
->GetState() == STATE_PAUSED
);
668 bool wxThread::TestDestroy()
670 wxCriticalSectionLocker
lock((wxCriticalSection
&)m_critsect
);
672 return p_internal
->GetState() == STATE_CANCELED
;
677 p_internal
= new wxThreadInternal();
680 wxThread::~wxThread()
685 // ----------------------------------------------------------------------------
686 // Automatic initialization for thread module
687 // ----------------------------------------------------------------------------
689 class wxThreadModule
: public wxModule
692 virtual bool OnInit();
693 virtual void OnExit();
696 DECLARE_DYNAMIC_CLASS(wxThreadModule
)
699 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule
, wxModule
)
701 bool wxThreadModule::OnInit()
703 // allocate TLS index for storing the pointer to the current thread
704 s_tlsThisThread
= ::TlsAlloc();
705 if ( s_tlsThisThread
== 0xFFFFFFFF )
707 // in normal circumstances it will only happen if all other
708 // TLS_MINIMUM_AVAILABLE (>= 64) indices are already taken - in other
709 // words, this should never happen
710 wxLogSysError(_("Thread module initialization failed: "
711 "impossible to allocate index in thread "
717 // main thread doesn't have associated wxThread object, so store 0 in the
719 if ( !::TlsSetValue(s_tlsThisThread
, (LPVOID
)0) )
721 ::TlsFree(s_tlsThisThread
);
722 s_tlsThisThread
= 0xFFFFFFFF;
724 wxLogSysError(_("Thread module initialization failed: "
725 "can not store value in thread local storage"));
730 s_critsectWaitingForGui
= new wxCriticalSection();
732 s_critsectGui
= new wxCriticalSection();
733 s_critsectGui
->Enter();
735 // no error return for GetCurrentThreadId()
736 s_idMainThread
= ::GetCurrentThreadId();
741 void wxThreadModule::OnExit()
743 if ( !::TlsFree(s_tlsThisThread
) )
745 wxLogLastError("TlsFree failed.");
750 s_critsectGui
->Leave();
751 delete s_critsectGui
;
752 s_critsectGui
= NULL
;
755 wxDELETE(s_critsectWaitingForGui
);
758 // ----------------------------------------------------------------------------
759 // under Windows, these functions are implemented usign a critical section and
760 // not a mutex, so the names are a bit confusing
761 // ----------------------------------------------------------------------------
763 void WXDLLEXPORT
wxMutexGuiEnter()
765 // this would dead lock everything...
766 wxASSERT_MSG( !wxThread::IsMain(),
767 "main thread doesn't want to block in wxMutexGuiEnter()!" );
769 // the order in which we enter the critical sections here is crucial!!
771 // set the flag telling to the main thread that we want to do some GUI
773 wxCriticalSectionLocker
enter(*s_critsectWaitingForGui
);
778 wxWakeUpMainThread();
780 // now we may block here because the main thread will soon let us in
781 // (during the next iteration of OnIdle())
782 s_critsectGui
->Enter();
785 void WXDLLEXPORT
wxMutexGuiLeave()
787 wxCriticalSectionLocker
enter(*s_critsectWaitingForGui
);
789 if ( wxThread::IsMain() )
791 s_bGuiOwnedByMainThread
= FALSE
;
795 // decrement the number of waiters now
796 wxASSERT_MSG( s_nWaitingForGui
> 0,
797 "calling wxMutexGuiLeave() without entering it first?" );
801 wxWakeUpMainThread();
804 s_critsectGui
->Leave();
807 void WXDLLEXPORT
wxMutexGuiLeaveOrEnter()
809 wxASSERT_MSG( wxThread::IsMain(),
810 "only main thread may call wxMutexGuiLeaveOrEnter()!" );
812 wxCriticalSectionLocker
enter(*s_critsectWaitingForGui
);
814 if ( s_nWaitingForGui
== 0 )
816 // no threads are waiting for GUI - so we may acquire the lock without
817 // any danger (but only if we don't already have it)
818 if ( !wxGuiOwnedByMainThread() )
820 s_critsectGui
->Enter();
822 s_bGuiOwnedByMainThread
= TRUE
;
824 //else: already have it, nothing to do
828 // some threads are waiting, release the GUI lock if we have it
829 if ( wxGuiOwnedByMainThread() )
833 //else: some other worker thread is doing GUI
837 bool WXDLLEXPORT
wxGuiOwnedByMainThread()
839 return s_bGuiOwnedByMainThread
;
842 // wake up the main thread if it's in ::GetMessage()
843 void WXDLLEXPORT
wxWakeUpMainThread()
845 // sending any message would do - hopefully WM_NULL is harmless enough
846 if ( !::PostThreadMessage(s_idMainThread
, WM_NULL
, 0, 0) )
848 // should never happen
849 wxLogLastError("PostThreadMessage(WM_NULL)");
853 bool WXDLLEXPORT
wxIsWaitingForThread()
855 return s_waitingForThread
;
858 #endif // wxUSE_THREADS