1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/unix/threadpsx.cpp
3 // Purpose: wxThread (Posix) Implementation
4 // Author: Original from Wolfram Gloger/Guilhem Lavaux
5 // Modified by: K. S. Sreeram (2002): POSIXified wxCondition, added wxSemaphore
8 // Copyright: (c) Wolfram Gloger (1996, 1997)
9 // Guilhem Lavaux (1998)
10 // Vadim Zeitlin (1999-2002)
11 // Robert Roebling (1999)
12 // K. S. Sreeram (2002)
13 // Licence: wxWindows licence
14 /////////////////////////////////////////////////////////////////////////////
16 // ============================================================================
18 // ============================================================================
20 // ----------------------------------------------------------------------------
22 // ----------------------------------------------------------------------------
24 // for compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
29 #include "wx/thread.h"
30 #include "wx/except.h"
34 #include "wx/dynarray.h"
39 #include "wx/stopwatch.h"
40 #include "wx/module.h"
48 #include <sys/time.h> // needed for at least __QNX__
53 #ifdef HAVE_THR_SETCONCURRENCY
57 #ifdef HAVE_ABI_FORCEDUNWIND
61 #ifdef HAVE_SETPRIORITY
62 #include <sys/resource.h> // for setpriority()
65 // we use wxFFile under Linux in GetCPUCount()
70 #define THR_ID_CAST(id) (reinterpret_cast<void*>(id))
71 #define THR_ID(thr) THR_ID_CAST((thr)->GetId())
73 // ----------------------------------------------------------------------------
75 // ----------------------------------------------------------------------------
77 // the possible states of the thread and transitions from them
80 STATE_NEW
, // didn't start execution yet (=> RUNNING)
81 STATE_RUNNING
, // running (=> PAUSED or EXITED)
82 STATE_PAUSED
, // suspended (=> RUNNING or EXITED)
83 STATE_EXITED
// thread doesn't exist any more
86 // the exit value of a thread which has been cancelled
87 static const wxThread
::ExitCode EXITCODE_CANCELLED
= (wxThread
::ExitCode
)-1;
89 // trace mask for wxThread operations
90 #define TRACE_THREADS wxT("thread")
92 // you can get additional debugging messages for the semaphore operations
93 #define TRACE_SEMA wxT("semaphore")
95 // ----------------------------------------------------------------------------
97 // ----------------------------------------------------------------------------
99 static void ScheduleThreadForDeletion();
100 static void DeleteThread(wxThread
*This
);
102 // ----------------------------------------------------------------------------
104 // ----------------------------------------------------------------------------
106 // an (non owning) array of pointers to threads
107 WX_DEFINE_ARRAY_PTR(wxThread
*, wxArrayThread
);
109 // an entry for a thread we can wait for
111 // -----------------------------------------------------------------------------
113 // -----------------------------------------------------------------------------
115 // we keep the list of all threads created by the application to be able to
116 // terminate them on exit if there are some left - otherwise the process would
118 static wxArrayThread gs_allThreads
;
120 // a mutex to protect gs_allThreads
121 static wxMutex
*gs_mutexAllThreads
= NULL
;
123 // the id of the main thread
125 // we suppose that 0 is not a valid pthread_t value but in principle this might
126 // be false (e.g. if it's a selector-like value), wxThread::IsMain() would need
127 // to be updated in such case
128 wxThreadIdType wxThread
::ms_idMainThread
= 0;
130 // the key for the pointer to the associated wxThread object
131 static pthread_key_t gs_keySelf
;
133 // the number of threads which are being deleted - the program won't exit
134 // until there are any left
135 static size_t gs_nThreadsBeingDeleted
= 0;
137 // a mutex to protect gs_nThreadsBeingDeleted
138 static wxMutex
*gs_mutexDeleteThread
= NULL
;
140 // and a condition variable which will be signaled when all
141 // gs_nThreadsBeingDeleted will have been deleted
142 static wxCondition
*gs_condAllDeleted
= NULL
;
145 // this mutex must be acquired before any call to a GUI function
146 // (it's not inside #if wxUSE_GUI because this file is compiled as part
148 static wxMutex
*gs_mutexGui
= NULL
;
151 // when we wait for a thread to exit, we're blocking on a condition which the
152 // thread signals in its SignalExit() method -- but this condition can't be a
153 // member of the thread itself as a detached thread may delete itself at any
154 // moment and accessing the condition member of the thread after this would
155 // result in a disaster
157 // so instead we maintain a global list of the structs below for the threads
158 // we're interested in waiting on
160 // ============================================================================
161 // wxMutex implementation
162 // ============================================================================
164 // ----------------------------------------------------------------------------
166 // ----------------------------------------------------------------------------
168 // this is a simple wrapper around pthread_mutex_t which provides error
170 class wxMutexInternal
173 wxMutexInternal(wxMutexType mutexType
);
177 wxMutexError
Lock(unsigned long ms
);
178 wxMutexError
TryLock();
179 wxMutexError
Unlock();
181 bool IsOk() const { return m_isOk
; }
184 // convert the result of pthread_mutex_[timed]lock() call to wx return code
185 wxMutexError
HandleLockResult(int err
);
188 pthread_mutex_t m_mutex
;
191 unsigned long m_owningThread
;
193 // wxConditionInternal uses our m_mutex
194 friend class wxConditionInternal
;
197 #if defined(HAVE_PTHREAD_MUTEXATTR_T) && \
198 wxUSE_UNIX && !defined(HAVE_PTHREAD_MUTEXATTR_SETTYPE_DECL)
199 // on some systems pthread_mutexattr_settype() is not in the headers (but it is
200 // in the library, otherwise we wouldn't compile this code at all)
201 extern "C" int pthread_mutexattr_settype(pthread_mutexattr_t
*, int);
204 wxMutexInternal
::wxMutexInternal(wxMutexType mutexType
)
212 case wxMUTEX_RECURSIVE
:
213 // support recursive locks like Win32, i.e. a thread can lock a
214 // mutex which it had itself already locked
216 // unfortunately initialization of recursive mutexes is non
217 // portable, so try several methods
218 #ifdef HAVE_PTHREAD_MUTEXATTR_T
220 pthread_mutexattr_t attr
;
221 pthread_mutexattr_init(&attr
);
222 pthread_mutexattr_settype(&attr
, PTHREAD_MUTEX_RECURSIVE
);
224 err
= pthread_mutex_init(&m_mutex
, &attr
);
226 #elif defined(HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
227 // we can use this only as initializer so we have to assign it
228 // first to a temp var - assigning directly to m_mutex wouldn't
231 pthread_mutex_t mutex
= PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
;
234 #else // no recursive mutexes
236 #endif // HAVE_PTHREAD_MUTEXATTR_T/...
240 wxFAIL_MSG( wxT("unknown mutex type") );
243 case wxMUTEX_DEFAULT
:
244 err
= pthread_mutex_init(&m_mutex
, NULL
);
251 wxLogApiError( wxT("pthread_mutex_init()"), err
);
255 wxMutexInternal
::~wxMutexInternal()
259 int err
= pthread_mutex_destroy(&m_mutex
);
262 wxLogApiError( wxT("pthread_mutex_destroy()"), err
);
267 wxMutexError wxMutexInternal
::Lock()
269 if ((m_type
== wxMUTEX_DEFAULT
) && (m_owningThread
!= 0))
271 if (m_owningThread
== wxThread
::GetCurrentId())
272 return wxMUTEX_DEAD_LOCK
;
275 return HandleLockResult(pthread_mutex_lock(&m_mutex
));
278 wxMutexError wxMutexInternal
::Lock(unsigned long ms
)
280 #ifdef HAVE_PTHREAD_MUTEX_TIMEDLOCK
281 static const long MSEC_IN_SEC
= 1000;
282 static const long NSEC_IN_MSEC
= 1000000;
283 static const long NSEC_IN_USEC
= 1000;
284 static const long NSEC_IN_SEC
= MSEC_IN_SEC
* NSEC_IN_MSEC
;
286 time_t seconds
= ms
/MSEC_IN_SEC
;
287 long nanoseconds
= (ms
% MSEC_IN_SEC
) * NSEC_IN_MSEC
;
288 timespec ts
= { 0, 0 };
290 // normally we should use clock_gettime(CLOCK_REALTIME) here but this
291 // function is in librt and we don't link with it currently, so use
292 // gettimeofday() instead -- if it turns out that this is really too
293 // imprecise, we should modify configure to check if clock_gettime() is
294 // available and whether it requires -lrt and use it instead
296 if ( clock_gettime(CLOCK_REALTIME
, &ts
) == 0 )
301 if ( wxGetTimeOfDay(&tv
) != -1 )
303 ts
.tv_sec
= tv
.tv_sec
;
304 ts
.tv_nsec
= tv
.tv_usec
*NSEC_IN_USEC
;
307 else // fall back on system timer
309 ts
.tv_sec
= time(NULL
);
312 ts
.tv_sec
+= seconds
;
313 ts
.tv_nsec
+= nanoseconds
;
314 if ( ts
.tv_nsec
> NSEC_IN_SEC
)
317 ts
.tv_nsec
-= NSEC_IN_SEC
;
320 return HandleLockResult(pthread_mutex_timedlock(&m_mutex
, &ts
));
321 #else // !HAVE_PTHREAD_MUTEX_TIMEDLOCK
324 return wxMUTEX_MISC_ERROR
;
325 #endif // HAVE_PTHREAD_MUTEX_TIMEDLOCK/!HAVE_PTHREAD_MUTEX_TIMEDLOCK
328 wxMutexError wxMutexInternal
::HandleLockResult(int err
)
330 // wxPrintf( "err %d\n", err );
335 // only error checking mutexes return this value and so it's an
336 // unexpected situation -- hence use assert, not wxLogDebug
337 wxFAIL_MSG( wxT("mutex deadlock prevented") );
338 return wxMUTEX_DEAD_LOCK
;
341 wxLogDebug(wxT("pthread_mutex_[timed]lock(): mutex not initialized"));
345 return wxMUTEX_TIMEOUT
;
348 if (m_type
== wxMUTEX_DEFAULT
)
349 m_owningThread
= wxThread
::GetCurrentId();
350 return wxMUTEX_NO_ERROR
;
353 wxLogApiError(wxT("pthread_mutex_[timed]lock()"), err
);
356 return wxMUTEX_MISC_ERROR
;
360 wxMutexError wxMutexInternal
::TryLock()
362 int err
= pthread_mutex_trylock(&m_mutex
);
366 // not an error: mutex is already locked, but we're prepared for
371 wxLogDebug(wxT("pthread_mutex_trylock(): mutex not initialized."));
375 if (m_type
== wxMUTEX_DEFAULT
)
376 m_owningThread
= wxThread
::GetCurrentId();
377 return wxMUTEX_NO_ERROR
;
380 wxLogApiError(wxT("pthread_mutex_trylock()"), err
);
383 return wxMUTEX_MISC_ERROR
;
386 wxMutexError wxMutexInternal
::Unlock()
390 int err
= pthread_mutex_unlock(&m_mutex
);
394 // we don't own the mutex
395 return wxMUTEX_UNLOCKED
;
398 wxLogDebug(wxT("pthread_mutex_unlock(): mutex not initialized."));
402 return wxMUTEX_NO_ERROR
;
405 wxLogApiError(wxT("pthread_mutex_unlock()"), err
);
408 return wxMUTEX_MISC_ERROR
;
411 // ===========================================================================
412 // wxCondition implementation
413 // ===========================================================================
415 // ---------------------------------------------------------------------------
416 // wxConditionInternal
417 // ---------------------------------------------------------------------------
419 // this is a wrapper around pthread_cond_t associated with a wxMutex (and hence
420 // with a pthread_mutex_t)
421 class wxConditionInternal
424 wxConditionInternal(wxMutex
& mutex
);
425 ~wxConditionInternal();
427 bool IsOk() const { return m_isOk
&& m_mutex
.IsOk(); }
430 wxCondError
WaitTimeout(unsigned long milliseconds
);
432 wxCondError
Signal();
433 wxCondError
Broadcast();
436 // get the POSIX mutex associated with us
437 pthread_mutex_t
*GetPMutex() const { return &m_mutex
.m_internal
->m_mutex
; }
440 pthread_cond_t m_cond
;
445 wxConditionInternal
::wxConditionInternal(wxMutex
& mutex
)
448 int err
= pthread_cond_init(&m_cond
, NULL
/* default attributes */);
454 wxLogApiError(wxT("pthread_cond_init()"), err
);
458 wxConditionInternal
::~wxConditionInternal()
462 int err
= pthread_cond_destroy(&m_cond
);
465 wxLogApiError(wxT("pthread_cond_destroy()"), err
);
470 wxCondError wxConditionInternal
::Wait()
472 int err
= pthread_cond_wait(&m_cond
, GetPMutex());
475 wxLogApiError(wxT("pthread_cond_wait()"), err
);
477 return wxCOND_MISC_ERROR
;
480 return wxCOND_NO_ERROR
;
483 wxCondError wxConditionInternal
::WaitTimeout(unsigned long milliseconds
)
485 wxLongLong curtime
= wxGetUTCTimeMillis();
486 curtime
+= milliseconds
;
487 wxLongLong temp
= curtime
/ 1000;
488 int sec
= temp
.GetLo();
490 temp
= curtime
- temp
;
491 int millis
= temp
.GetLo();
496 tspec
.tv_nsec
= millis
* 1000L * 1000L;
498 int err
= pthread_cond_timedwait( &m_cond
, GetPMutex(), &tspec
);
502 return wxCOND_TIMEOUT
;
505 return wxCOND_NO_ERROR
;
508 wxLogApiError(wxT("pthread_cond_timedwait()"), err
);
511 return wxCOND_MISC_ERROR
;
514 wxCondError wxConditionInternal
::Signal()
516 int err
= pthread_cond_signal(&m_cond
);
519 wxLogApiError(wxT("pthread_cond_signal()"), err
);
521 return wxCOND_MISC_ERROR
;
524 return wxCOND_NO_ERROR
;
527 wxCondError wxConditionInternal
::Broadcast()
529 int err
= pthread_cond_broadcast(&m_cond
);
532 wxLogApiError(wxT("pthread_cond_broadcast()"), err
);
534 return wxCOND_MISC_ERROR
;
537 return wxCOND_NO_ERROR
;
540 // ===========================================================================
541 // wxSemaphore implementation
542 // ===========================================================================
544 // ---------------------------------------------------------------------------
545 // wxSemaphoreInternal
546 // ---------------------------------------------------------------------------
548 // we implement the semaphores using mutexes and conditions instead of using
549 // the sem_xxx() POSIX functions because they're not widely available and also
550 // because it's impossible to implement WaitTimeout() using them
551 class wxSemaphoreInternal
554 wxSemaphoreInternal(int initialcount
, int maxcount
);
556 bool IsOk() const { return m_isOk
; }
559 wxSemaError
TryWait();
560 wxSemaError
WaitTimeout(unsigned long milliseconds
);
574 wxSemaphoreInternal
::wxSemaphoreInternal(int initialcount
, int maxcount
)
578 if ( (initialcount
< 0 || maxcount
< 0) ||
579 ((maxcount
> 0) && (initialcount
> maxcount
)) )
581 wxFAIL_MSG( wxT("wxSemaphore: invalid initial or maximal count") );
587 m_maxcount
= (size_t)maxcount
;
588 m_count
= (size_t)initialcount
;
591 m_isOk
= m_mutex
.IsOk() && m_cond
.IsOk();
594 wxSemaError wxSemaphoreInternal
::Wait()
596 wxMutexLocker
locker(m_mutex
);
598 while ( m_count
== 0 )
600 wxLogTrace(TRACE_SEMA
,
601 wxT("Thread %p waiting for semaphore to become signalled"),
602 THR_ID_CAST(wxThread
::GetCurrentId()));
604 if ( m_cond
.Wait() != wxCOND_NO_ERROR
)
605 return wxSEMA_MISC_ERROR
;
607 wxLogTrace(TRACE_SEMA
,
608 wxT("Thread %p finished waiting for semaphore, count = %lu"),
609 THR_ID_CAST(wxThread
::GetCurrentId()), (unsigned long)m_count
);
614 return wxSEMA_NO_ERROR
;
617 wxSemaError wxSemaphoreInternal
::TryWait()
619 wxMutexLocker
locker(m_mutex
);
626 return wxSEMA_NO_ERROR
;
629 wxSemaError wxSemaphoreInternal
::WaitTimeout(unsigned long milliseconds
)
631 wxMutexLocker
locker(m_mutex
);
633 wxLongLong startTime
= wxGetLocalTimeMillis();
635 while ( m_count
== 0 )
637 wxLongLong elapsed
= wxGetLocalTimeMillis() - startTime
;
638 long remainingTime
= (long)milliseconds
- (long)elapsed
.GetLo();
639 if ( remainingTime
<= 0 )
642 return wxSEMA_TIMEOUT
;
645 switch ( m_cond
.WaitTimeout(remainingTime
) )
648 return wxSEMA_TIMEOUT
;
651 return wxSEMA_MISC_ERROR
;
653 case wxCOND_NO_ERROR
:
660 return wxSEMA_NO_ERROR
;
663 wxSemaError wxSemaphoreInternal
::Post()
665 wxMutexLocker
locker(m_mutex
);
667 if ( m_maxcount
> 0 && m_count
== m_maxcount
)
669 return wxSEMA_OVERFLOW
;
674 wxLogTrace(TRACE_SEMA
,
675 wxT("Thread %p about to signal semaphore, count = %lu"),
676 THR_ID_CAST(wxThread
::GetCurrentId()), (unsigned long)m_count
);
678 return m_cond
.Signal() == wxCOND_NO_ERROR ? wxSEMA_NO_ERROR
682 // ===========================================================================
683 // wxThread implementation
684 // ===========================================================================
686 // the thread callback functions must have the C linkage
690 #ifdef wxHAVE_PTHREAD_CLEANUP
691 // thread exit function
692 void wxPthreadCleanup(void *ptr
);
693 #endif // wxHAVE_PTHREAD_CLEANUP
695 void *wxPthreadStart(void *ptr
);
699 // ----------------------------------------------------------------------------
701 // ----------------------------------------------------------------------------
703 class wxThreadInternal
709 // thread entry function
710 static void *PthreadStart(wxThread
*thread
);
714 wxThreadError
Create(wxThread
*thread
, unsigned int stackSize
);
717 // unblock the thread allowing it to run
718 void SignalRun() { m_semRun
.Post(); }
719 // ask the thread to terminate
721 // go to sleep until Resume() is called
728 int GetPriority() const { return m_prio
; }
729 void SetPriority(int prio
) { m_prio
= prio
; }
731 wxThreadState
GetState() const { return m_state
; }
732 void SetState(wxThreadState state
)
735 static const wxChar
*const stateNames
[] =
743 wxLogTrace(TRACE_THREADS
, wxT("Thread %p: %s => %s."),
744 THR_ID(this), stateNames
[m_state
], stateNames
[state
]);
745 #endif // wxUSE_LOG_TRACE
750 pthread_t
GetId() const { return m_threadId
; }
751 pthread_t
*GetIdPtr() { return &m_threadId
; }
753 void SetCancelFlag() { m_cancelled
= true; }
754 bool WasCancelled() const { return m_cancelled
; }
756 void SetExitCode(wxThread
::ExitCode exitcode
) { m_exitcode
= exitcode
; }
757 wxThread
::ExitCode
GetExitCode() const { return m_exitcode
; }
760 void SetReallyPaused(bool paused
) { m_isPaused
= paused
; }
761 bool IsReallyPaused() const { return m_isPaused
; }
763 // tell the thread that it is a detached one
766 wxCriticalSectionLocker
lock(m_csJoinFlag
);
768 m_shouldBeJoined
= false;
772 #ifdef wxHAVE_PTHREAD_CLEANUP
773 // this is used by wxPthreadCleanup() only
774 static void Cleanup(wxThread
*thread
);
775 #endif // wxHAVE_PTHREAD_CLEANUP
778 pthread_t m_threadId
; // id of the thread
779 wxThreadState m_state
; // see wxThreadState enum
780 int m_prio
; // in wxWidgets units: from 0 to 100
782 // this flag is set when the thread should terminate
785 // this flag is set when the thread is blocking on m_semSuspend
788 // the thread exit code - only used for joinable (!detached) threads and
789 // is only valid after the thread termination
790 wxThread
::ExitCode m_exitcode
;
792 // many threads may call Wait(), but only one of them should call
793 // pthread_join(), so we have to keep track of this
794 wxCriticalSection m_csJoinFlag
;
795 bool m_shouldBeJoined
;
798 // this semaphore is posted by Run() and the threads Entry() is not
799 // called before it is done
800 wxSemaphore m_semRun
;
802 // this one is signaled when the thread should resume after having been
804 wxSemaphore m_semSuspend
;
807 // ----------------------------------------------------------------------------
808 // thread startup and exit functions
809 // ----------------------------------------------------------------------------
811 void *wxPthreadStart(void *ptr
)
813 return wxThreadInternal
::PthreadStart((wxThread
*)ptr
);
816 void *wxThreadInternal
::PthreadStart(wxThread
*thread
)
818 wxThreadInternal
*pthread
= thread
->m_internal
;
820 wxLogTrace(TRACE_THREADS
, wxT("Thread %p started."), THR_ID(pthread
));
822 // associate the thread pointer with the newly created thread so that
823 // wxThread::This() will work
824 int rc
= pthread_setspecific(gs_keySelf
, thread
);
827 wxLogSysError(rc
, _("Cannot start thread: error writing TLS."));
832 // have to declare this before pthread_cleanup_push() which defines a
836 #ifdef wxHAVE_PTHREAD_CLEANUP
837 // install the cleanup handler which will be called if the thread is
839 pthread_cleanup_push(wxPthreadCleanup
, thread
);
840 #endif // wxHAVE_PTHREAD_CLEANUP
842 // wait for the semaphore to be posted from Run()
843 pthread
->m_semRun
.Wait();
845 // test whether we should run the run at all - may be it was deleted
846 // before it started to Run()?
848 wxCriticalSectionLocker
lock(thread
->m_critsect
);
850 dontRunAtAll
= pthread
->GetState() == STATE_NEW
&&
851 pthread
->WasCancelled();
856 // call the main entry
857 wxLogTrace(TRACE_THREADS
,
858 wxT("Thread %p about to enter its Entry()."),
863 pthread
->m_exitcode
= thread
->Entry();
865 wxLogTrace(TRACE_THREADS
,
866 wxT("Thread %p Entry() returned %lu."),
867 THR_ID(pthread
), wxPtrToUInt(pthread
->m_exitcode
));
869 #ifdef HAVE_ABI_FORCEDUNWIND
870 // When using common C++ ABI under Linux we must always rethrow this
871 // special exception used to unwind the stack when the thread was
872 // cancelled, otherwise the thread library would simply terminate the
873 // program, see http://udrepper.livejournal.com/21541.html
874 catch ( abi
::__forced_unwind
& )
876 wxCriticalSectionLocker
lock(thread
->m_critsect
);
877 pthread
->SetState(STATE_EXITED
);
880 #endif // HAVE_ABI_FORCEDUNWIND
881 wxCATCH_ALL( wxTheApp
->OnUnhandledException(); )
884 wxCriticalSectionLocker
lock(thread
->m_critsect
);
886 // change the state of the thread to "exited" so that
887 // wxPthreadCleanup handler won't do anything from now (if it's
888 // called before we do pthread_cleanup_pop below)
889 pthread
->SetState(STATE_EXITED
);
893 // NB: pthread_cleanup_push/pop() are macros and pop contains the matching
894 // '}' for the '{' in push, so they must be used in the same block!
895 #ifdef wxHAVE_PTHREAD_CLEANUP
897 // under Tru64 we get a warning from macro expansion
899 #pragma message disable(declbutnotref)
902 // remove the cleanup handler without executing it
903 pthread_cleanup_pop(FALSE
);
906 #pragma message restore
908 #endif // wxHAVE_PTHREAD_CLEANUP
912 // FIXME: deleting a possibly joinable thread here???
915 return EXITCODE_CANCELLED
;
919 // terminate the thread
920 thread
->Exit(pthread
->m_exitcode
);
922 wxFAIL_MSG(wxT("wxThread::Exit() can't return."));
928 #ifdef wxHAVE_PTHREAD_CLEANUP
930 // this handler is called when the thread is cancelled
931 extern "C" void wxPthreadCleanup(void *ptr
)
933 wxThreadInternal
::Cleanup((wxThread
*)ptr
);
936 void wxThreadInternal
::Cleanup(wxThread
*thread
)
938 if (pthread_getspecific(gs_keySelf
) == 0) return;
940 wxCriticalSectionLocker
lock(thread
->m_critsect
);
941 if ( thread
->m_internal
->GetState() == STATE_EXITED
)
943 // thread is already considered as finished.
948 // exit the thread gracefully
949 thread
->Exit(EXITCODE_CANCELLED
);
952 #endif // wxHAVE_PTHREAD_CLEANUP
954 // ----------------------------------------------------------------------------
956 // ----------------------------------------------------------------------------
958 wxThreadInternal
::wxThreadInternal()
962 m_prio
= wxPRIORITY_DEFAULT
;
966 // set to true only when the thread starts waiting on m_semSuspend
969 // defaults for joinable threads
970 m_shouldBeJoined
= true;
971 m_isDetached
= false;
974 wxThreadInternal
::~wxThreadInternal()
978 #ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
979 #define WXUNUSED_STACKSIZE(identifier) identifier
981 #define WXUNUSED_STACKSIZE(identifier) WXUNUSED(identifier)
984 wxThreadError wxThreadInternal
::Create(wxThread
*thread
,
985 unsigned int WXUNUSED_STACKSIZE(stackSize
))
987 if ( GetState() != STATE_NEW
)
989 // don't recreate thread
990 return wxTHREAD_RUNNING
;
993 // set up the thread attribute: right now, we only set thread priority
995 pthread_attr_init(&attr
);
997 #ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
999 pthread_attr_setstacksize(&attr
, stackSize
);
1002 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
1004 if ( pthread_attr_getschedpolicy(&attr
, &policy
) != 0 )
1006 wxLogError(_("Cannot retrieve thread scheduling policy."));
1010 /* the pthread.h contains too many spaces. This is a work-around */
1011 # undef sched_get_priority_max
1012 #undef sched_get_priority_min
1013 #define sched_get_priority_max(_pol_) \
1014 (_pol_ == SCHED_OTHER ? PRI_FG_MAX_NP : PRI_FIFO_MAX)
1015 #define sched_get_priority_min(_pol_) \
1016 (_pol_ == SCHED_OTHER ? PRI_FG_MIN_NP : PRI_FIFO_MIN)
1019 int max_prio
= sched_get_priority_max(policy
),
1020 min_prio
= sched_get_priority_min(policy
),
1021 prio
= GetPriority();
1023 if ( min_prio
== -1 || max_prio
== -1 )
1025 wxLogError(_("Cannot get priority range for scheduling policy %d."),
1028 else if ( max_prio
== min_prio
)
1030 if ( prio
!= wxPRIORITY_DEFAULT
)
1032 // notify the programmer that this doesn't work here
1033 wxLogWarning(_("Thread priority setting is ignored."));
1035 //else: we have default priority, so don't complain
1037 // anyhow, don't do anything because priority is just ignored
1041 struct sched_param sp
;
1042 if ( pthread_attr_getschedparam(&attr
, &sp
) != 0 )
1044 wxFAIL_MSG(wxT("pthread_attr_getschedparam() failed"));
1047 sp
.sched_priority
= min_prio
+ (prio
*(max_prio
- min_prio
))/100;
1049 if ( pthread_attr_setschedparam(&attr
, &sp
) != 0 )
1051 wxFAIL_MSG(wxT("pthread_attr_setschedparam(priority) failed"));
1054 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS
1056 #ifdef HAVE_PTHREAD_ATTR_SETSCOPE
1057 // this will make the threads created by this process really concurrent
1058 if ( pthread_attr_setscope(&attr
, PTHREAD_SCOPE_SYSTEM
) != 0 )
1060 wxFAIL_MSG(wxT("pthread_attr_setscope(PTHREAD_SCOPE_SYSTEM) failed"));
1062 #endif // HAVE_PTHREAD_ATTR_SETSCOPE
1064 // VZ: assume that this one is always available (it's rather fundamental),
1065 // if this function is ever missing we should try to use
1066 // pthread_detach() instead (after thread creation)
1067 if ( thread
->IsDetached() )
1069 if ( pthread_attr_setdetachstate(&attr
, PTHREAD_CREATE_DETACHED
) != 0 )
1071 wxFAIL_MSG(wxT("pthread_attr_setdetachstate(DETACHED) failed"));
1074 // never try to join detached threads
1077 //else: threads are created joinable by default, it's ok
1079 // create the new OS thread object
1080 int rc
= pthread_create
1088 if ( pthread_attr_destroy(&attr
) != 0 )
1090 wxFAIL_MSG(wxT("pthread_attr_destroy() failed"));
1095 SetState(STATE_EXITED
);
1097 return wxTHREAD_NO_RESOURCE
;
1100 return wxTHREAD_NO_ERROR
;
1103 wxThreadError wxThreadInternal
::Run()
1105 wxCHECK_MSG( GetState() == STATE_NEW
, wxTHREAD_RUNNING
,
1106 wxT("thread may only be started once after Create()") );
1108 SetState(STATE_RUNNING
);
1110 // wake up threads waiting for our start
1113 return wxTHREAD_NO_ERROR
;
1116 void wxThreadInternal
::Wait()
1118 wxCHECK_RET( !m_isDetached
, wxT("can't wait for a detached thread") );
1120 // if the thread we're waiting for is waiting for the GUI mutex, we will
1121 // deadlock so make sure we release it temporarily
1122 if ( wxThread
::IsMain() )
1125 // give the thread we're waiting for chance to do the GUI call
1126 // it might be in, we don't do this conditionally as the to be waited on
1127 // thread might have to acquire the mutex later but before terminating
1128 if ( wxGuiOwnedByMainThread() )
1135 wxLogTrace(TRACE_THREADS
,
1136 wxT("Starting to wait for thread %p to exit."),
1139 // to avoid memory leaks we should call pthread_join(), but it must only be
1140 // done once so use a critical section to serialize the code below
1142 wxCriticalSectionLocker
lock(m_csJoinFlag
);
1144 if ( m_shouldBeJoined
)
1146 // FIXME shouldn't we set cancellation type to DISABLED here? If
1147 // we're cancelled inside pthread_join(), things will almost
1148 // certainly break - but if we disable the cancellation, we
1150 if ( pthread_join(GetId(), &m_exitcode
) != 0 )
1152 // this is a serious problem, so use wxLogError and not
1153 // wxLogDebug: it is possible to bring the system to its knees
1154 // by creating too many threads and not joining them quite
1156 wxLogError(_("Failed to join a thread, potential memory leak detected - please restart the program"));
1159 m_shouldBeJoined
= false;
1164 // reacquire GUI mutex
1165 if ( wxThread
::IsMain() )
1170 void wxThreadInternal
::Pause()
1172 // the state is set from the thread which pauses us first, this function
1173 // is called later so the state should have been already set
1174 wxCHECK_RET( m_state
== STATE_PAUSED
,
1175 wxT("thread must first be paused with wxThread::Pause().") );
1177 wxLogTrace(TRACE_THREADS
,
1178 wxT("Thread %p goes to sleep."), THR_ID(this));
1180 // wait until the semaphore is Post()ed from Resume()
1181 m_semSuspend
.Wait();
1184 void wxThreadInternal
::Resume()
1186 wxCHECK_RET( m_state
== STATE_PAUSED
,
1187 wxT("can't resume thread which is not suspended.") );
1189 // the thread might be not actually paused yet - if there were no call to
1190 // TestDestroy() since the last call to Pause() for example
1191 if ( IsReallyPaused() )
1193 wxLogTrace(TRACE_THREADS
,
1194 wxT("Waking up thread %p"), THR_ID(this));
1197 m_semSuspend
.Post();
1200 SetReallyPaused(false);
1204 wxLogTrace(TRACE_THREADS
,
1205 wxT("Thread %p is not yet really paused"), THR_ID(this));
1208 SetState(STATE_RUNNING
);
1211 // -----------------------------------------------------------------------------
1212 // wxThread static functions
1213 // -----------------------------------------------------------------------------
1215 wxThread
*wxThread
::This()
1217 return (wxThread
*)pthread_getspecific(gs_keySelf
);
1220 void wxThread
::Yield()
1222 #ifdef HAVE_SCHED_YIELD
1227 int wxThread
::GetCPUCount()
1229 #if defined(_SC_NPROCESSORS_ONLN)
1230 // this works for Solaris and Linux 2.6
1231 int rc
= sysconf(_SC_NPROCESSORS_ONLN
);
1236 #elif defined(__LINUX__) && wxUSE_FFILE
1237 // read from proc (can't use wxTextFile here because it's a special file:
1238 // it has 0 size but still can be read from)
1241 wxFFile
file(wxT("/proc/cpuinfo"));
1242 if ( file
.IsOpened() )
1244 // slurp the whole file
1246 if ( file
.ReadAll(&s
) )
1248 // (ab)use Replace() to find the number of "processor: num" strings
1249 size_t count
= s
.Replace(wxT("processor\t:"), wxT(""));
1255 wxLogDebug(wxT("failed to parse /proc/cpuinfo"));
1259 wxLogDebug(wxT("failed to read /proc/cpuinfo"));
1262 #endif // different ways to get number of CPUs
1268 wxThreadIdType wxThread
::GetCurrentId()
1270 return (wxThreadIdType
)pthread_self();
1274 bool wxThread
::SetConcurrency(size_t level
)
1276 #ifdef HAVE_PTHREAD_SET_CONCURRENCY
1277 int rc
= pthread_setconcurrency( level
);
1278 #elif defined(HAVE_THR_SETCONCURRENCY)
1279 int rc
= thr_setconcurrency(level
);
1280 #else // !HAVE_THR_SETCONCURRENCY
1281 // ok only for the default value
1282 int rc
= level
== 0 ?
0 : -1;
1283 #endif // HAVE_THR_SETCONCURRENCY/!HAVE_THR_SETCONCURRENCY
1287 wxLogSysError(rc
, _("Failed to set thread concurrency level to %lu"),
1288 static_cast<unsigned long>(level
));
1295 // -----------------------------------------------------------------------------
1297 // -----------------------------------------------------------------------------
1299 wxThread
::wxThread(wxThreadKind kind
)
1301 // add this thread to the global list of all threads
1303 wxMutexLocker
lock(*gs_mutexAllThreads
);
1305 gs_allThreads
.Add(this);
1308 m_internal
= new wxThreadInternal();
1310 m_isDetached
= kind
== wxTHREAD_DETACHED
;
1313 wxThreadError wxThread
::Create(unsigned int stackSize
)
1315 wxCriticalSectionLocker
lock(m_critsect
);
1317 return m_internal
->Create(this, stackSize
);
1320 wxThreadError wxThread
::Run()
1322 wxCriticalSectionLocker
lock(m_critsect
);
1324 wxCHECK_MSG( m_internal
->GetId(), wxTHREAD_MISC_ERROR
,
1325 wxT("must call wxThread::Create() first") );
1327 return m_internal
->Run();
1330 // -----------------------------------------------------------------------------
1332 // -----------------------------------------------------------------------------
1334 void wxThread
::SetPriority(unsigned int prio
)
1336 wxCHECK_RET( wxPRIORITY_MIN
<= prio
&& prio
<= wxPRIORITY_MAX
,
1337 wxT("invalid thread priority") );
1339 wxCriticalSectionLocker
lock(m_critsect
);
1341 switch ( m_internal
->GetState() )
1344 // thread not yet started, priority will be set when it is
1345 m_internal
->SetPriority(prio
);
1350 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
1351 #if defined(__LINUX__)
1352 // On Linux, pthread_setschedparam with SCHED_OTHER does not allow
1353 // a priority other than 0. Instead, we use the BSD setpriority
1354 // which alllows us to set a 'nice' value between 20 to -20. Only
1355 // super user can set a value less than zero (more negative yields
1356 // higher priority). setpriority set the static priority of a
1357 // process, but this is OK since Linux is configured as a thread
1360 // FIXME this is not true for 2.6!!
1362 // map wx priorites 0..100 to Unix priorities 20..-20
1363 if ( setpriority(PRIO_PROCESS
, 0, -(2*(int)prio
)/5 + 20) == -1 )
1365 wxLogError(_("Failed to set thread priority %d."), prio
);
1369 struct sched_param sparam
;
1370 sparam
.sched_priority
= prio
;
1372 if ( pthread_setschedparam(m_internal
->GetId(),
1373 SCHED_OTHER
, &sparam
) != 0 )
1375 wxLogError(_("Failed to set thread priority %d."), prio
);
1379 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS
1384 wxFAIL_MSG(wxT("impossible to set thread priority in this state"));
1388 unsigned int wxThread
::GetPriority() const
1390 wxCriticalSectionLocker
lock((wxCriticalSection
&)m_critsect
);
1392 return m_internal
->GetPriority();
1395 wxThreadIdType wxThread
::GetId() const
1397 return (wxThreadIdType
) m_internal
->GetId();
1400 // -----------------------------------------------------------------------------
1402 // -----------------------------------------------------------------------------
1404 wxThreadError wxThread
::Pause()
1406 wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR
,
1407 wxT("a thread can't pause itself") );
1409 wxCriticalSectionLocker
lock(m_critsect
);
1411 if ( m_internal
->GetState() != STATE_RUNNING
)
1413 wxLogDebug(wxT("Can't pause thread which is not running."));
1415 return wxTHREAD_NOT_RUNNING
;
1418 // just set a flag, the thread will be really paused only during the next
1419 // call to TestDestroy()
1420 m_internal
->SetState(STATE_PAUSED
);
1422 return wxTHREAD_NO_ERROR
;
1425 wxThreadError wxThread
::Resume()
1427 wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR
,
1428 wxT("a thread can't resume itself") );
1430 wxCriticalSectionLocker
lock(m_critsect
);
1432 wxThreadState state
= m_internal
->GetState();
1437 wxLogTrace(TRACE_THREADS
, wxT("Thread %p suspended, resuming."),
1440 m_internal
->Resume();
1442 return wxTHREAD_NO_ERROR
;
1445 wxLogTrace(TRACE_THREADS
, wxT("Thread %p exited, won't resume."),
1447 return wxTHREAD_NO_ERROR
;
1450 wxLogDebug(wxT("Attempt to resume a thread which is not paused."));
1452 return wxTHREAD_MISC_ERROR
;
1456 // -----------------------------------------------------------------------------
1458 // -----------------------------------------------------------------------------
1460 wxThread
::ExitCode wxThread
::Wait(wxThreadWait
WXUNUSED(waitMode
))
1462 wxCHECK_MSG( This() != this, (ExitCode
)-1,
1463 wxT("a thread can't wait for itself") );
1465 wxCHECK_MSG( !m_isDetached
, (ExitCode
)-1,
1466 wxT("can't wait for detached thread") );
1470 return m_internal
->GetExitCode();
1473 wxThreadError wxThread
::Delete(ExitCode
*rc
, wxThreadWait
WXUNUSED(waitMode
))
1475 wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR
,
1476 wxT("a thread can't delete itself") );
1478 bool isDetached
= m_isDetached
;
1481 wxThreadState state
= m_internal
->GetState();
1483 // ask the thread to stop
1484 m_internal
->SetCancelFlag();
1493 // we need to wake up the thread so that PthreadStart() will
1494 // terminate - right now it's blocking on run semaphore in
1496 m_internal
->SignalRun();
1505 // resume the thread first
1506 m_internal
->Resume();
1513 // wait until the thread stops
1518 // return the exit code of the thread
1519 *rc
= m_internal
->GetExitCode();
1522 //else: can't wait for detached threads
1525 if (state
== STATE_NEW
)
1526 return wxTHREAD_MISC_ERROR
;
1527 // for coherency with the MSW implementation, signal the user that
1528 // Delete() was called on a thread which didn't start to run yet.
1530 return wxTHREAD_NO_ERROR
;
1533 wxThreadError wxThread
::Kill()
1535 wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR
,
1536 wxT("a thread can't kill itself") );
1540 switch ( m_internal
->GetState() )
1544 return wxTHREAD_NOT_RUNNING
;
1547 // resume the thread first
1553 #ifdef HAVE_PTHREAD_CANCEL
1554 if ( pthread_cancel(m_internal
->GetId()) != 0 )
1555 #endif // HAVE_PTHREAD_CANCEL
1557 wxLogError(_("Failed to terminate a thread."));
1559 return wxTHREAD_MISC_ERROR
;
1562 #ifdef HAVE_PTHREAD_CANCEL
1565 // if we use cleanup function, this will be done from
1566 // wxPthreadCleanup()
1567 #ifndef wxHAVE_PTHREAD_CLEANUP
1568 ScheduleThreadForDeletion();
1570 // don't call OnExit() here, it can only be called in the
1571 // threads context and we're in the context of another thread
1574 #endif // wxHAVE_PTHREAD_CLEANUP
1578 m_internal
->SetExitCode(EXITCODE_CANCELLED
);
1581 return wxTHREAD_NO_ERROR
;
1582 #endif // HAVE_PTHREAD_CANCEL
1586 void wxThread
::Exit(ExitCode status
)
1588 wxASSERT_MSG( This() == this,
1589 wxT("wxThread::Exit() can only be called in the context of the same thread") );
1593 // from the moment we call OnExit(), the main program may terminate at
1594 // any moment, so mark this thread as being already in process of being
1595 // deleted or wxThreadModule::OnExit() will try to delete it again
1596 ScheduleThreadForDeletion();
1599 // don't enter m_critsect before calling OnExit() because the user code
1600 // might deadlock if, for example, it signals a condition in OnExit() (a
1601 // common case) while the main thread calls any of functions entering
1602 // m_critsect on us (almost all of them do)
1607 wxCATCH_ALL( wxTheApp
->OnUnhandledException(); )
1609 // delete C++ thread object if this is a detached thread - user is
1610 // responsible for doing this for joinable ones
1613 // FIXME I'm feeling bad about it - what if another thread function is
1614 // called (in another thread context) now? It will try to access
1615 // half destroyed object which will probably result in something
1616 // very bad - but we can't protect this by a crit section unless
1617 // we make it a global object, but this would mean that we can
1618 // only call one thread function at a time :-(
1620 pthread_setspecific(gs_keySelf
, 0);
1625 m_internal
->SetState(STATE_EXITED
);
1629 // terminate the thread (pthread_exit() never returns)
1630 pthread_exit(status
);
1632 wxFAIL_MSG(wxT("pthread_exit() failed"));
1635 // also test whether we were paused
1636 bool wxThread
::TestDestroy()
1638 wxASSERT_MSG( This() == this,
1639 wxT("wxThread::TestDestroy() can only be called in the context of the same thread") );
1643 if ( m_internal
->GetState() == STATE_PAUSED
)
1645 m_internal
->SetReallyPaused(true);
1647 // leave the crit section or the other threads will stop too if they
1648 // try to call any of (seemingly harmless) IsXXX() functions while we
1652 m_internal
->Pause();
1656 // thread wasn't requested to pause, nothing to do
1660 return m_internal
->WasCancelled();
1663 wxThread
::~wxThread()
1667 // check that the thread either exited or couldn't be created
1668 if ( m_internal
->GetState() != STATE_EXITED
&&
1669 m_internal
->GetState() != STATE_NEW
)
1671 wxLogDebug(wxT("The thread %p is being destroyed although it is still running! The application may crash."),
1679 // remove this thread from the global array
1681 wxMutexLocker
lock(*gs_mutexAllThreads
);
1683 gs_allThreads
.Remove(this);
1687 // -----------------------------------------------------------------------------
1689 // -----------------------------------------------------------------------------
1691 bool wxThread
::IsRunning() const
1693 wxCriticalSectionLocker
lock((wxCriticalSection
&)m_critsect
);
1695 return m_internal
->GetState() == STATE_RUNNING
;
1698 bool wxThread
::IsAlive() const
1700 wxCriticalSectionLocker
lock((wxCriticalSection
&)m_critsect
);
1702 switch ( m_internal
->GetState() )
1713 bool wxThread
::IsPaused() const
1715 wxCriticalSectionLocker
lock((wxCriticalSection
&)m_critsect
);
1717 return (m_internal
->GetState() == STATE_PAUSED
);
1720 //--------------------------------------------------------------------
1722 //--------------------------------------------------------------------
1725 void wxOSXThreadModuleOnInit();
1726 void wxOSXThreadModuleOnExit();
1729 class wxThreadModule
: public wxModule
1732 virtual bool OnInit();
1733 virtual void OnExit();
1736 DECLARE_DYNAMIC_CLASS(wxThreadModule
)
1739 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule
, wxModule
)
1741 bool wxThreadModule
::OnInit()
1743 int rc
= pthread_key_create(&gs_keySelf
, NULL
/* dtor function */);
1746 wxLogSysError(rc
, _("Thread module initialization failed: failed to create thread key"));
1751 wxThread
::ms_idMainThread
= wxThread
::GetCurrentId();
1753 gs_mutexAllThreads
= new wxMutex();
1756 wxOSXThreadModuleOnInit();
1758 gs_mutexGui
= new wxMutex();
1759 gs_mutexGui
->Lock();
1762 gs_mutexDeleteThread
= new wxMutex();
1763 gs_condAllDeleted
= new wxCondition(*gs_mutexDeleteThread
);
1768 void wxThreadModule
::OnExit()
1770 wxASSERT_MSG( wxThread
::IsMain(), wxT("only main thread can be here") );
1772 // are there any threads left which are being deleted right now?
1773 size_t nThreadsBeingDeleted
;
1776 wxMutexLocker
lock( *gs_mutexDeleteThread
);
1777 nThreadsBeingDeleted
= gs_nThreadsBeingDeleted
;
1779 if ( nThreadsBeingDeleted
> 0 )
1781 wxLogTrace(TRACE_THREADS
,
1782 wxT("Waiting for %lu threads to disappear"),
1783 (unsigned long)nThreadsBeingDeleted
);
1785 // have to wait until all of them disappear
1786 gs_condAllDeleted
->Wait();
1793 wxMutexLocker
lock(*gs_mutexAllThreads
);
1795 // terminate any threads left
1796 count
= gs_allThreads
.GetCount();
1799 wxLogDebug(wxT("%lu threads were not terminated by the application."),
1800 (unsigned long)count
);
1802 } // unlock mutex before deleting the threads as they lock it in their dtor
1804 for ( size_t n
= 0u; n
< count
; n
++ )
1806 // Delete calls the destructor which removes the current entry. We
1807 // should only delete the first one each time.
1808 gs_allThreads
[0]->Delete();
1811 delete gs_mutexAllThreads
;
1814 wxOSXThreadModuleOnExit();
1816 // destroy GUI mutex
1817 gs_mutexGui
->Unlock();
1821 // and free TLD slot
1822 (void)pthread_key_delete(gs_keySelf
);
1824 delete gs_condAllDeleted
;
1825 delete gs_mutexDeleteThread
;
1828 // ----------------------------------------------------------------------------
1830 // ----------------------------------------------------------------------------
1832 static void ScheduleThreadForDeletion()
1834 wxMutexLocker
lock( *gs_mutexDeleteThread
);
1836 gs_nThreadsBeingDeleted
++;
1838 wxLogTrace(TRACE_THREADS
, wxT("%lu thread%s waiting to be deleted"),
1839 (unsigned long)gs_nThreadsBeingDeleted
,
1840 gs_nThreadsBeingDeleted
== 1 ?
wxT("") : wxT("s"));
1843 static void DeleteThread(wxThread
*This
)
1845 wxLogTrace(TRACE_THREADS
, wxT("Thread %p auto deletes."), THR_ID(This
));
1849 // only lock gs_mutexDeleteThread after deleting the thread to avoid
1850 // calling out into user code with it locked as this may result in
1851 // deadlocks if the thread dtor deletes another thread (see #11501)
1852 wxMutexLocker
locker( *gs_mutexDeleteThread
);
1854 wxCHECK_RET( gs_nThreadsBeingDeleted
> 0,
1855 wxT("no threads scheduled for deletion, yet we delete one?") );
1857 wxLogTrace(TRACE_THREADS
, wxT("%lu threads remain scheduled for deletion."),
1858 (unsigned long)gs_nThreadsBeingDeleted
- 1);
1860 if ( !--gs_nThreadsBeingDeleted
)
1862 // no more threads left, signal it
1863 gs_condAllDeleted
->Signal();
1869 void wxMutexGuiEnterImpl()
1871 gs_mutexGui
->Lock();
1874 void wxMutexGuiLeaveImpl()
1876 gs_mutexGui
->Unlock();
1881 // ----------------------------------------------------------------------------
1882 // include common implementation code
1883 // ----------------------------------------------------------------------------
1885 #include "wx/thrimpl.cpp"
1887 #endif // wxUSE_THREADS