]> git.saurik.com Git - wxWidgets.git/blob - src/msw/thread.cpp
adapting new osx modifier handling, fixes #14377
[wxWidgets.git] / src / msw / thread.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/thread.cpp
3 // Purpose: wxThread Implementation
4 // Author: Original from Wolfram Gloger/Guilhem Lavaux
5 // Modified by: Vadim Zeitlin to make it work :-)
6 // Created: 04/22/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Wolfram Gloger (1996, 1997), Guilhem Lavaux (1998);
9 // Vadim Zeitlin (1999-2002)
10 // Licence: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
12
13 // ----------------------------------------------------------------------------
14 // headers
15 // ----------------------------------------------------------------------------
16
17 // For compilers that support precompilation, includes "wx.h".
18 #include "wx/wxprec.h"
19
20 #if defined(__BORLANDC__)
21 #pragma hdrstop
22 #endif
23
24 #if wxUSE_THREADS
25
26 #include "wx/thread.h"
27
28 #ifndef WX_PRECOMP
29 #include "wx/intl.h"
30 #include "wx/app.h"
31 #include "wx/module.h"
32 #endif
33
34 #include "wx/apptrait.h"
35 #include "wx/scopeguard.h"
36
37 #include "wx/msw/private.h"
38 #include "wx/msw/missing.h"
39 #include "wx/msw/seh.h"
40
41 #include "wx/except.h"
42
43 #include "wx/dynlib.h"
44
45 // must have this symbol defined to get _beginthread/_endthread declarations
46 #ifndef _MT
47 #define _MT
48 #endif
49
50 #if defined(__BORLANDC__)
51 #if !defined(__MT__)
52 // I can't set -tWM in the IDE (anyone?) so have to do this
53 #define __MT__
54 #endif
55
56 #if !defined(__MFC_COMPAT__)
57 // Needed to know about _beginthreadex etc..
58 #define __MFC_COMPAT__
59 #endif
60 #endif // BC++
61
62 // define wxUSE_BEGIN_THREAD if the compiler has _beginthreadex() function
63 // which should be used instead of Win32 ::CreateThread() if possible
64 #if defined(__VISUALC__) || \
65 (defined(__BORLANDC__) && (__BORLANDC__ >= 0x500)) || \
66 (defined(__GNUG__) && defined(__MSVCRT__)) || \
67 defined(__WATCOMC__)
68
69 #ifndef __WXWINCE__
70 #undef wxUSE_BEGIN_THREAD
71 #define wxUSE_BEGIN_THREAD
72 #endif
73
74 #endif
75
76 #ifdef wxUSE_BEGIN_THREAD
77 // this is where _beginthreadex() is declared
78 #include <process.h>
79
80 // the return type of the thread function entry point: notice that this
81 // type can't hold a pointer under Win64
82 typedef unsigned THREAD_RETVAL;
83
84 // the calling convention of the thread function entry point
85 #define THREAD_CALLCONV __stdcall
86 #else
87 // the settings for CreateThread()
88 typedef DWORD THREAD_RETVAL;
89 #define THREAD_CALLCONV WINAPI
90 #endif
91
92 static const THREAD_RETVAL THREAD_ERROR_EXIT = (THREAD_RETVAL)-1;
93
94 // ----------------------------------------------------------------------------
95 // constants
96 // ----------------------------------------------------------------------------
97
98 // the possible states of the thread ("=>" shows all possible transitions from
99 // this state)
100 enum wxThreadState
101 {
102 STATE_NEW, // didn't start execution yet (=> RUNNING)
103 STATE_RUNNING, // thread is running (=> PAUSED, CANCELED)
104 STATE_PAUSED, // thread is temporarily suspended (=> RUNNING)
105 STATE_CANCELED, // thread should terminate a.s.a.p. (=> EXITED)
106 STATE_EXITED // thread is terminating
107 };
108
109 // ----------------------------------------------------------------------------
110 // this module globals
111 // ----------------------------------------------------------------------------
112
113 // TLS index of the slot where we store the pointer to the current thread
114 static DWORD gs_tlsThisThread = 0xFFFFFFFF;
115
116 // id of the main thread - the one which can call GUI functions without first
117 // calling wxMutexGuiEnter()
118 wxThreadIdType wxThread::ms_idMainThread = 0;
119
120 // if it's false, some secondary thread is holding the GUI lock
121 static bool gs_bGuiOwnedByMainThread = true;
122
123 // critical section which controls access to all GUI functions: any secondary
124 // thread (i.e. except the main one) must enter this crit section before doing
125 // any GUI calls
126 static wxCriticalSection *gs_critsectGui = NULL;
127
128 // critical section which protects gs_nWaitingForGui variable
129 static wxCriticalSection *gs_critsectWaitingForGui = NULL;
130
131 // critical section which serializes WinThreadStart() and WaitForTerminate()
132 // (this is a potential bottleneck, we use a single crit sect for all threads
133 // in the system, but normally time spent inside it should be quite short)
134 static wxCriticalSection *gs_critsectThreadDelete = NULL;
135
136 // number of threads waiting for GUI in wxMutexGuiEnter()
137 static size_t gs_nWaitingForGui = 0;
138
139 // are we waiting for a thread termination?
140 static bool gs_waitingForThread = false;
141
142 // ============================================================================
143 // Windows implementation of thread and related classes
144 // ============================================================================
145
146 // ----------------------------------------------------------------------------
147 // wxCriticalSection
148 // ----------------------------------------------------------------------------
149
150 wxCriticalSection::wxCriticalSection( wxCriticalSectionType WXUNUSED(critSecType) )
151 {
152 wxCOMPILE_TIME_ASSERT( sizeof(CRITICAL_SECTION) <= sizeof(wxCritSectBuffer),
153 wxCriticalSectionBufferTooSmall );
154
155 ::InitializeCriticalSection((CRITICAL_SECTION *)m_buffer);
156 }
157
158 wxCriticalSection::~wxCriticalSection()
159 {
160 ::DeleteCriticalSection((CRITICAL_SECTION *)m_buffer);
161 }
162
163 void wxCriticalSection::Enter()
164 {
165 ::EnterCriticalSection((CRITICAL_SECTION *)m_buffer);
166 }
167
168 bool wxCriticalSection::TryEnter()
169 {
170 #if wxUSE_DYNLIB_CLASS
171 typedef BOOL
172 (WINAPI *TryEnterCriticalSection_t)(LPCRITICAL_SECTION lpCriticalSection);
173
174 static TryEnterCriticalSection_t
175 pfnTryEnterCriticalSection = (TryEnterCriticalSection_t)
176 wxDynamicLibrary(wxT("kernel32.dll")).
177 GetSymbol(wxT("TryEnterCriticalSection"));
178
179 return pfnTryEnterCriticalSection
180 ? (*pfnTryEnterCriticalSection)((CRITICAL_SECTION *)m_buffer) != 0
181 : false;
182 #else
183 return false;
184 #endif
185 }
186
187 void wxCriticalSection::Leave()
188 {
189 ::LeaveCriticalSection((CRITICAL_SECTION *)m_buffer);
190 }
191
192 // ----------------------------------------------------------------------------
193 // wxMutex
194 // ----------------------------------------------------------------------------
195
196 class wxMutexInternal
197 {
198 public:
199 wxMutexInternal(wxMutexType mutexType);
200 ~wxMutexInternal();
201
202 bool IsOk() const { return m_mutex != NULL; }
203
204 wxMutexError Lock() { return LockTimeout(INFINITE); }
205 wxMutexError Lock(unsigned long ms) { return LockTimeout(ms); }
206 wxMutexError TryLock();
207 wxMutexError Unlock();
208
209 private:
210 wxMutexError LockTimeout(DWORD milliseconds);
211
212 HANDLE m_mutex;
213
214 unsigned long m_owningThread;
215 wxMutexType m_type;
216
217 wxDECLARE_NO_COPY_CLASS(wxMutexInternal);
218 };
219
220 // all mutexes are recursive under Win32 so we don't use mutexType
221 wxMutexInternal::wxMutexInternal(wxMutexType mutexType)
222 {
223 // create a nameless (hence intra process and always private) mutex
224 m_mutex = ::CreateMutex
225 (
226 NULL, // default secutiry attributes
227 FALSE, // not initially locked
228 NULL // no name
229 );
230
231 m_type = mutexType;
232 m_owningThread = 0;
233
234 if ( !m_mutex )
235 {
236 wxLogLastError(wxT("CreateMutex()"));
237 }
238
239 }
240
241 wxMutexInternal::~wxMutexInternal()
242 {
243 if ( m_mutex )
244 {
245 if ( !::CloseHandle(m_mutex) )
246 {
247 wxLogLastError(wxT("CloseHandle(mutex)"));
248 }
249 }
250 }
251
252 wxMutexError wxMutexInternal::TryLock()
253 {
254 const wxMutexError rc = LockTimeout(0);
255
256 // we have a special return code for timeout in this case
257 return rc == wxMUTEX_TIMEOUT ? wxMUTEX_BUSY : rc;
258 }
259
260 wxMutexError wxMutexInternal::LockTimeout(DWORD milliseconds)
261 {
262 if (m_type == wxMUTEX_DEFAULT)
263 {
264 // Don't allow recursive
265 if (m_owningThread != 0)
266 {
267 if (m_owningThread == wxThread::GetCurrentId())
268 return wxMUTEX_DEAD_LOCK;
269 }
270 }
271
272 DWORD rc = ::WaitForSingleObject(m_mutex, milliseconds);
273 switch ( rc )
274 {
275 case WAIT_ABANDONED:
276 // the previous caller died without releasing the mutex, so even
277 // though we did get it, log a message about this
278 wxLogDebug(wxT("WaitForSingleObject() returned WAIT_ABANDONED"));
279 // fall through
280
281 case WAIT_OBJECT_0:
282 // ok
283 break;
284
285 case WAIT_TIMEOUT:
286 return wxMUTEX_TIMEOUT;
287
288 default:
289 wxFAIL_MSG(wxT("impossible return value in wxMutex::Lock"));
290 // fall through
291
292 case WAIT_FAILED:
293 wxLogLastError(wxT("WaitForSingleObject(mutex)"));
294 return wxMUTEX_MISC_ERROR;
295 }
296
297 if (m_type == wxMUTEX_DEFAULT)
298 {
299 // required for checking recursiveness
300 m_owningThread = wxThread::GetCurrentId();
301 }
302
303 return wxMUTEX_NO_ERROR;
304 }
305
306 wxMutexError wxMutexInternal::Unlock()
307 {
308 // required for checking recursiveness
309 m_owningThread = 0;
310
311 if ( !::ReleaseMutex(m_mutex) )
312 {
313 wxLogLastError(wxT("ReleaseMutex()"));
314
315 return wxMUTEX_MISC_ERROR;
316 }
317
318 return wxMUTEX_NO_ERROR;
319 }
320
321 // --------------------------------------------------------------------------
322 // wxSemaphore
323 // --------------------------------------------------------------------------
324
325 // a trivial wrapper around Win32 semaphore
326 class wxSemaphoreInternal
327 {
328 public:
329 wxSemaphoreInternal(int initialcount, int maxcount);
330 ~wxSemaphoreInternal();
331
332 bool IsOk() const { return m_semaphore != NULL; }
333
334 wxSemaError Wait() { return WaitTimeout(INFINITE); }
335
336 wxSemaError TryWait()
337 {
338 wxSemaError rc = WaitTimeout(0);
339 if ( rc == wxSEMA_TIMEOUT )
340 rc = wxSEMA_BUSY;
341
342 return rc;
343 }
344
345 wxSemaError WaitTimeout(unsigned long milliseconds);
346
347 wxSemaError Post();
348
349 private:
350 HANDLE m_semaphore;
351
352 wxDECLARE_NO_COPY_CLASS(wxSemaphoreInternal);
353 };
354
355 wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
356 {
357 #if !defined(_WIN32_WCE) || (_WIN32_WCE >= 300)
358 if ( maxcount == 0 )
359 {
360 // make it practically infinite
361 maxcount = INT_MAX;
362 }
363
364 m_semaphore = ::CreateSemaphore
365 (
366 NULL, // default security attributes
367 initialcount,
368 maxcount,
369 NULL // no name
370 );
371 #endif
372 if ( !m_semaphore )
373 {
374 wxLogLastError(wxT("CreateSemaphore()"));
375 }
376 }
377
378 wxSemaphoreInternal::~wxSemaphoreInternal()
379 {
380 if ( m_semaphore )
381 {
382 if ( !::CloseHandle(m_semaphore) )
383 {
384 wxLogLastError(wxT("CloseHandle(semaphore)"));
385 }
386 }
387 }
388
389 wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds)
390 {
391 DWORD rc = ::WaitForSingleObject( m_semaphore, milliseconds );
392
393 switch ( rc )
394 {
395 case WAIT_OBJECT_0:
396 return wxSEMA_NO_ERROR;
397
398 case WAIT_TIMEOUT:
399 return wxSEMA_TIMEOUT;
400
401 default:
402 wxLogLastError(wxT("WaitForSingleObject(semaphore)"));
403 }
404
405 return wxSEMA_MISC_ERROR;
406 }
407
408 wxSemaError wxSemaphoreInternal::Post()
409 {
410 #if !defined(_WIN32_WCE) || (_WIN32_WCE >= 300)
411 if ( !::ReleaseSemaphore(m_semaphore, 1, NULL /* ptr to previous count */) )
412 {
413 if ( GetLastError() == ERROR_TOO_MANY_POSTS )
414 {
415 return wxSEMA_OVERFLOW;
416 }
417 else
418 {
419 wxLogLastError(wxT("ReleaseSemaphore"));
420 return wxSEMA_MISC_ERROR;
421 }
422 }
423
424 return wxSEMA_NO_ERROR;
425 #else
426 return wxSEMA_MISC_ERROR;
427 #endif
428 }
429
430 // ----------------------------------------------------------------------------
431 // wxThread implementation
432 // ----------------------------------------------------------------------------
433
434 // wxThreadInternal class
435 // ----------------------
436
437 class wxThreadInternal
438 {
439 public:
440 wxThreadInternal(wxThread *thread)
441 {
442 m_thread = thread;
443 m_hThread = 0;
444 m_state = STATE_NEW;
445 m_priority = WXTHREAD_DEFAULT_PRIORITY;
446 m_nRef = 1;
447 }
448
449 ~wxThreadInternal()
450 {
451 Free();
452 }
453
454 void Free()
455 {
456 if ( m_hThread )
457 {
458 if ( !::CloseHandle(m_hThread) )
459 {
460 wxLogLastError(wxT("CloseHandle(thread)"));
461 }
462
463 m_hThread = 0;
464 }
465 }
466
467 // create a new (suspended) thread (for the given thread object)
468 bool Create(wxThread *thread, unsigned int stackSize);
469
470 // wait for the thread to terminate, either by itself, or by asking it
471 // (politely, this is not Kill()!) to do it
472 wxThreadError WaitForTerminate(wxCriticalSection& cs,
473 wxThread::ExitCode *pRc,
474 wxThreadWait waitMode,
475 wxThread *threadToDelete = NULL);
476
477 // kill the thread unconditionally
478 wxThreadError Kill();
479
480 // suspend/resume/terminate
481 bool Suspend();
482 bool Resume();
483 void Cancel() { m_state = STATE_CANCELED; }
484
485 // thread state
486 void SetState(wxThreadState state) { m_state = state; }
487 wxThreadState GetState() const { return m_state; }
488
489 // thread priority
490 void SetPriority(unsigned int priority);
491 unsigned int GetPriority() const { return m_priority; }
492
493 // thread handle and id
494 HANDLE GetHandle() const { return m_hThread; }
495 DWORD GetId() const { return m_tid; }
496
497 // the thread function forwarding to DoThreadStart
498 static THREAD_RETVAL THREAD_CALLCONV WinThreadStart(void *thread);
499
500 // really start the thread (if it's not already dead)
501 static THREAD_RETVAL DoThreadStart(wxThread *thread);
502
503 // call OnExit() on the thread
504 static void DoThreadOnExit(wxThread *thread);
505
506
507 void KeepAlive()
508 {
509 if ( m_thread->IsDetached() )
510 ::InterlockedIncrement(&m_nRef);
511 }
512
513 void LetDie()
514 {
515 if ( m_thread->IsDetached() && !::InterlockedDecrement(&m_nRef) )
516 delete m_thread;
517 }
518
519 private:
520 // the thread we're associated with
521 wxThread *m_thread;
522
523 HANDLE m_hThread; // handle of the thread
524 wxThreadState m_state; // state, see wxThreadState enum
525 unsigned int m_priority; // thread priority in "wx" units
526 DWORD m_tid; // thread id
527
528 // number of threads which need this thread to remain alive, when the count
529 // reaches 0 we kill the owning wxThread -- and die ourselves with it
530 LONG m_nRef;
531
532 wxDECLARE_NO_COPY_CLASS(wxThreadInternal);
533 };
534
535 // small class which keeps a thread alive during its lifetime
536 class wxThreadKeepAlive
537 {
538 public:
539 wxThreadKeepAlive(wxThreadInternal& thrImpl) : m_thrImpl(thrImpl)
540 { m_thrImpl.KeepAlive(); }
541 ~wxThreadKeepAlive()
542 { m_thrImpl.LetDie(); }
543
544 private:
545 wxThreadInternal& m_thrImpl;
546 };
547
548 /* static */
549 void wxThreadInternal::DoThreadOnExit(wxThread *thread)
550 {
551 wxTRY
552 {
553 thread->OnExit();
554 }
555 wxCATCH_ALL( wxTheApp->OnUnhandledException(); )
556 }
557
558 /* static */
559 THREAD_RETVAL wxThreadInternal::DoThreadStart(wxThread *thread)
560 {
561 wxON_BLOCK_EXIT1(DoThreadOnExit, thread);
562
563 THREAD_RETVAL rc = THREAD_ERROR_EXIT;
564
565 wxTRY
566 {
567 // store the thread object in the TLS
568 if ( !::TlsSetValue(gs_tlsThisThread, thread) )
569 {
570 wxLogSysError(_("Cannot start thread: error writing TLS."));
571
572 return THREAD_ERROR_EXIT;
573 }
574
575 rc = wxPtrToUInt(thread->Entry());
576 }
577 wxCATCH_ALL( wxTheApp->OnUnhandledException(); )
578
579 return rc;
580 }
581
582 /* static */
583 THREAD_RETVAL THREAD_CALLCONV wxThreadInternal::WinThreadStart(void *param)
584 {
585 THREAD_RETVAL rc = THREAD_ERROR_EXIT;
586
587 wxThread * const thread = (wxThread *)param;
588
589 // each thread has its own SEH translator so install our own a.s.a.p.
590 DisableAutomaticSETranslator();
591
592 // first of all, check whether we hadn't been cancelled already and don't
593 // start the user code at all then
594 const bool hasExited = thread->m_internal->GetState() == STATE_EXITED;
595
596 // run the thread function itself inside a SEH try/except block
597 wxSEH_TRY
598 {
599 if ( hasExited )
600 DoThreadOnExit(thread);
601 else
602 rc = DoThreadStart(thread);
603 }
604 wxSEH_HANDLE(THREAD_ERROR_EXIT)
605
606
607 // save IsDetached because thread object can be deleted by joinable
608 // threads after state is changed to STATE_EXITED.
609 const bool isDetached = thread->IsDetached();
610 if ( !hasExited )
611 {
612 // enter m_critsect before changing the thread state
613 //
614 // NB: can't use wxCriticalSectionLocker here as we use SEH and it's
615 // incompatible with C++ object dtors
616 thread->m_critsect.Enter();
617 thread->m_internal->SetState(STATE_EXITED);
618 thread->m_critsect.Leave();
619 }
620
621 // the thread may delete itself now if it wants, we don't need it any more
622 if ( isDetached )
623 thread->m_internal->LetDie();
624
625 return rc;
626 }
627
628 void wxThreadInternal::SetPriority(unsigned int priority)
629 {
630 m_priority = priority;
631
632 // translate wxWidgets priority to the Windows one
633 int win_priority;
634 if (m_priority <= 20)
635 win_priority = THREAD_PRIORITY_LOWEST;
636 else if (m_priority <= 40)
637 win_priority = THREAD_PRIORITY_BELOW_NORMAL;
638 else if (m_priority <= 60)
639 win_priority = THREAD_PRIORITY_NORMAL;
640 else if (m_priority <= 80)
641 win_priority = THREAD_PRIORITY_ABOVE_NORMAL;
642 else if (m_priority <= 100)
643 win_priority = THREAD_PRIORITY_HIGHEST;
644 else
645 {
646 wxFAIL_MSG(wxT("invalid value of thread priority parameter"));
647 win_priority = THREAD_PRIORITY_NORMAL;
648 }
649
650 if ( !::SetThreadPriority(m_hThread, win_priority) )
651 {
652 wxLogSysError(_("Can't set thread priority"));
653 }
654 }
655
656 bool wxThreadInternal::Create(wxThread *thread, unsigned int stackSize)
657 {
658 wxASSERT_MSG( m_state == STATE_NEW && !m_hThread,
659 wxT("Create()ing thread twice?") );
660
661 // for compilers which have it, we should use C RTL function for thread
662 // creation instead of Win32 API one because otherwise we will have memory
663 // leaks if the thread uses C RTL (and most threads do)
664 #ifdef wxUSE_BEGIN_THREAD
665
666 // Watcom is reported to not like 0 stack size (which means "use default"
667 // for the other compilers and is also the default value for stackSize)
668 #ifdef __WATCOMC__
669 if ( !stackSize )
670 stackSize = 10240;
671 #endif // __WATCOMC__
672
673 m_hThread = (HANDLE)_beginthreadex
674 (
675 NULL, // default security
676 stackSize,
677 wxThreadInternal::WinThreadStart, // entry point
678 thread,
679 CREATE_SUSPENDED,
680 (unsigned int *)&m_tid
681 );
682 #else // compiler doesn't have _beginthreadex
683 m_hThread = ::CreateThread
684 (
685 NULL, // default security
686 stackSize, // stack size
687 wxThreadInternal::WinThreadStart, // thread entry point
688 (LPVOID)thread, // parameter
689 CREATE_SUSPENDED, // flags
690 &m_tid // [out] thread id
691 );
692 #endif // _beginthreadex/CreateThread
693
694 if ( m_hThread == NULL )
695 {
696 wxLogSysError(_("Can't create thread"));
697
698 return false;
699 }
700
701 if ( m_priority != WXTHREAD_DEFAULT_PRIORITY )
702 {
703 SetPriority(m_priority);
704 }
705
706 return true;
707 }
708
709 wxThreadError wxThreadInternal::Kill()
710 {
711 m_thread->OnKill();
712
713 if ( !::TerminateThread(m_hThread, THREAD_ERROR_EXIT) )
714 {
715 wxLogSysError(_("Couldn't terminate thread"));
716
717 return wxTHREAD_MISC_ERROR;
718 }
719
720 Free();
721
722 return wxTHREAD_NO_ERROR;
723 }
724
725 wxThreadError
726 wxThreadInternal::WaitForTerminate(wxCriticalSection& cs,
727 wxThread::ExitCode *pRc,
728 wxThreadWait waitMode,
729 wxThread *threadToDelete)
730 {
731 // prevent the thread C++ object from disappearing as long as we are using
732 // it here
733 wxThreadKeepAlive keepAlive(*this);
734
735
736 // we may either wait passively for the thread to terminate (when called
737 // from Wait()) or ask it to terminate (when called from Delete())
738 bool shouldDelete = threadToDelete != NULL;
739
740 DWORD rc = 0;
741
742 // we might need to resume the thread if it's currently stopped
743 bool shouldResume = false;
744
745 // as Delete() (which calls us) is always safe to call we need to consider
746 // all possible states
747 {
748 wxCriticalSectionLocker lock(cs);
749
750 if ( m_state == STATE_NEW )
751 {
752 if ( shouldDelete )
753 {
754 // WinThreadStart() will see it and terminate immediately, no
755 // need to cancel the thread -- but we still need to resume it
756 // to let it run
757 m_state = STATE_EXITED;
758
759 // we must call Resume() as the thread hasn't been initially
760 // resumed yet (and as Resume() it knows about STATE_EXITED
761 // special case, it won't touch it and WinThreadStart() will
762 // just exit immediately)
763 shouldResume = true;
764 shouldDelete = false;
765 }
766 //else: shouldResume is correctly set to false here, wait until
767 // someone else runs the thread and it finishes
768 }
769 else // running, paused, cancelled or even exited
770 {
771 shouldResume = m_state == STATE_PAUSED;
772 }
773 }
774
775 // resume the thread if it is paused
776 if ( shouldResume )
777 Resume();
778
779 // ask the thread to terminate
780 if ( shouldDelete )
781 {
782 wxCriticalSectionLocker lock(cs);
783
784 Cancel();
785 }
786
787 if ( threadToDelete )
788 threadToDelete->OnDelete();
789
790 // now wait for thread to finish
791 if ( wxThread::IsMain() )
792 {
793 // set flag for wxIsWaitingForThread()
794 gs_waitingForThread = true;
795 }
796
797 // we can't just wait for the thread to terminate because it might be
798 // calling some GUI functions and so it will never terminate before we
799 // process the Windows messages that result from these functions
800 // (note that even in console applications we might have to process
801 // messages if we use wxExecute() or timers or ...)
802 DWORD result wxDUMMY_INITIALIZE(0);
803 do
804 {
805 if ( wxThread::IsMain() )
806 {
807 // give the thread we're waiting for chance to do the GUI call
808 // it might be in
809 if ( (gs_nWaitingForGui > 0) && wxGuiOwnedByMainThread() )
810 {
811 wxMutexGuiLeave();
812 }
813 }
814
815 wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
816 if ( traits )
817 {
818 result = traits->WaitForThread(m_hThread, waitMode);
819 }
820 else // can't wait for the thread
821 {
822 // so kill it below
823 result = 0xFFFFFFFF;
824 }
825
826 switch ( result )
827 {
828 case 0xFFFFFFFF:
829 // error
830 wxLogSysError(_("Cannot wait for thread termination"));
831 Kill();
832 return wxTHREAD_KILLED;
833
834 case WAIT_OBJECT_0:
835 // thread we're waiting for terminated
836 break;
837
838 case WAIT_OBJECT_0 + 1:
839 // new message arrived, process it -- but only if we're the
840 // main thread as we don't support processing messages in
841 // the other ones
842 //
843 // NB: we still must include QS_ALLINPUT even when waiting
844 // in a secondary thread because if it had created some
845 // window somehow (possible not even using wxWidgets)
846 // the system might dead lock then
847 if ( wxThread::IsMain() )
848 {
849 if ( traits && !traits->DoMessageFromThreadWait() )
850 {
851 // WM_QUIT received: kill the thread
852 Kill();
853
854 return wxTHREAD_KILLED;
855 }
856 }
857 break;
858
859 default:
860 wxFAIL_MSG(wxT("unexpected result of MsgWaitForMultipleObject"));
861 }
862 } while ( result != WAIT_OBJECT_0 );
863
864 if ( wxThread::IsMain() )
865 {
866 gs_waitingForThread = false;
867 }
868
869
870 // although the thread might be already in the EXITED state it might not
871 // have terminated yet and so we are not sure that it has actually
872 // terminated if the "if" above hadn't been taken
873 for ( ;; )
874 {
875 if ( !::GetExitCodeThread(m_hThread, &rc) )
876 {
877 wxLogLastError(wxT("GetExitCodeThread"));
878
879 rc = THREAD_ERROR_EXIT;
880
881 break;
882 }
883
884 if ( rc != STILL_ACTIVE )
885 break;
886
887 // give the other thread some time to terminate, otherwise we may be
888 // starving it
889 ::Sleep(1);
890 }
891
892 if ( pRc )
893 *pRc = wxUIntToPtr(rc);
894
895 // we don't need the thread handle any more in any case
896 Free();
897
898
899 return rc == THREAD_ERROR_EXIT ? wxTHREAD_MISC_ERROR : wxTHREAD_NO_ERROR;
900 }
901
902 bool wxThreadInternal::Suspend()
903 {
904 DWORD nSuspendCount = ::SuspendThread(m_hThread);
905 if ( nSuspendCount == (DWORD)-1 )
906 {
907 wxLogSysError(_("Cannot suspend thread %x"), m_hThread);
908
909 return false;
910 }
911
912 m_state = STATE_PAUSED;
913
914 return true;
915 }
916
917 bool wxThreadInternal::Resume()
918 {
919 DWORD nSuspendCount = ::ResumeThread(m_hThread);
920 if ( nSuspendCount == (DWORD)-1 )
921 {
922 wxLogSysError(_("Cannot resume thread %x"), m_hThread);
923
924 return false;
925 }
926
927 // don't change the state from STATE_EXITED because it's special and means
928 // we are going to terminate without running any user code - if we did it,
929 // the code in WaitForTerminate() wouldn't work
930 if ( m_state != STATE_EXITED )
931 {
932 m_state = STATE_RUNNING;
933 }
934
935 return true;
936 }
937
938 // static functions
939 // ----------------
940
941 wxThread *wxThread::This()
942 {
943 wxThread *thread = (wxThread *)::TlsGetValue(gs_tlsThisThread);
944
945 // be careful, 0 may be a valid return value as well
946 if ( !thread && (::GetLastError() != NO_ERROR) )
947 {
948 wxLogSysError(_("Couldn't get the current thread pointer"));
949
950 // return NULL...
951 }
952
953 return thread;
954 }
955
956 void wxThread::Yield()
957 {
958 // 0 argument to Sleep() is special and means to just give away the rest of
959 // our timeslice
960 ::Sleep(0);
961 }
962
963 int wxThread::GetCPUCount()
964 {
965 SYSTEM_INFO si;
966 GetSystemInfo(&si);
967
968 return si.dwNumberOfProcessors;
969 }
970
971 unsigned long wxThread::GetCurrentId()
972 {
973 return (unsigned long)::GetCurrentThreadId();
974 }
975
976 bool wxThread::SetConcurrency(size_t WXUNUSED_IN_WINCE(level))
977 {
978 #ifdef __WXWINCE__
979 return false;
980 #else
981 wxASSERT_MSG( IsMain(), wxT("should only be called from the main thread") );
982
983 // ok only for the default one
984 if ( level == 0 )
985 return 0;
986
987 // get system affinity mask first
988 HANDLE hProcess = ::GetCurrentProcess();
989 DWORD_PTR dwProcMask, dwSysMask;
990 if ( ::GetProcessAffinityMask(hProcess, &dwProcMask, &dwSysMask) == 0 )
991 {
992 wxLogLastError(wxT("GetProcessAffinityMask"));
993
994 return false;
995 }
996
997 // how many CPUs have we got?
998 if ( dwSysMask == 1 )
999 {
1000 // don't bother with all this complicated stuff - on a single
1001 // processor system it doesn't make much sense anyhow
1002 return level == 1;
1003 }
1004
1005 // calculate the process mask: it's a bit vector with one bit per
1006 // processor; we want to schedule the process to run on first level
1007 // CPUs
1008 DWORD bit = 1;
1009 while ( bit )
1010 {
1011 if ( dwSysMask & bit )
1012 {
1013 // ok, we can set this bit
1014 dwProcMask |= bit;
1015
1016 // another process added
1017 if ( --level == 0 )
1018 {
1019 // and that's enough
1020 break;
1021 }
1022 }
1023
1024 // next bit
1025 bit <<= 1;
1026 }
1027
1028 // could we set all bits?
1029 if ( level != 0 )
1030 {
1031 wxLogDebug(wxT("bad level %u in wxThread::SetConcurrency()"), level);
1032
1033 return false;
1034 }
1035
1036 // set it: we can't link to SetProcessAffinityMask() because it doesn't
1037 // exist in Win9x, use RT binding instead
1038
1039 typedef BOOL (WINAPI *SETPROCESSAFFINITYMASK)(HANDLE, DWORD_PTR);
1040
1041 // can use static var because we're always in the main thread here
1042 static SETPROCESSAFFINITYMASK pfnSetProcessAffinityMask = NULL;
1043
1044 if ( !pfnSetProcessAffinityMask )
1045 {
1046 HMODULE hModKernel = ::LoadLibrary(wxT("kernel32"));
1047 if ( hModKernel )
1048 {
1049 pfnSetProcessAffinityMask = (SETPROCESSAFFINITYMASK)
1050 ::GetProcAddress(hModKernel, "SetProcessAffinityMask");
1051 }
1052
1053 // we've discovered a MT version of Win9x!
1054 wxASSERT_MSG( pfnSetProcessAffinityMask,
1055 wxT("this system has several CPUs but no SetProcessAffinityMask function?") );
1056 }
1057
1058 if ( !pfnSetProcessAffinityMask )
1059 {
1060 // msg given above - do it only once
1061 return false;
1062 }
1063
1064 if ( pfnSetProcessAffinityMask(hProcess, dwProcMask) == 0 )
1065 {
1066 wxLogLastError(wxT("SetProcessAffinityMask"));
1067
1068 return false;
1069 }
1070
1071 return true;
1072 #endif // __WXWINCE__/!__WXWINCE__
1073 }
1074
1075 // ctor and dtor
1076 // -------------
1077
1078 wxThread::wxThread(wxThreadKind kind)
1079 {
1080 m_internal = new wxThreadInternal(this);
1081
1082 m_isDetached = kind == wxTHREAD_DETACHED;
1083 }
1084
1085 wxThread::~wxThread()
1086 {
1087 delete m_internal;
1088 }
1089
1090 // create/start thread
1091 // -------------------
1092
1093 wxThreadError wxThread::Create(unsigned int stackSize)
1094 {
1095 wxCriticalSectionLocker lock(m_critsect);
1096
1097 if ( !m_internal->Create(this, stackSize) )
1098 return wxTHREAD_NO_RESOURCE;
1099
1100 return wxTHREAD_NO_ERROR;
1101 }
1102
1103 wxThreadError wxThread::Run()
1104 {
1105 wxCriticalSectionLocker lock(m_critsect);
1106
1107 wxCHECK_MSG( m_internal->GetState() == STATE_NEW, wxTHREAD_RUNNING,
1108 wxT("thread may only be started once after Create()") );
1109
1110 // the thread has just been created and is still suspended - let it run
1111 return Resume();
1112 }
1113
1114 // suspend/resume thread
1115 // ---------------------
1116
1117 wxThreadError wxThread::Pause()
1118 {
1119 wxCriticalSectionLocker lock(m_critsect);
1120
1121 return m_internal->Suspend() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
1122 }
1123
1124 wxThreadError wxThread::Resume()
1125 {
1126 wxCriticalSectionLocker lock(m_critsect);
1127
1128 return m_internal->Resume() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
1129 }
1130
1131 // stopping thread
1132 // ---------------
1133
1134 wxThread::ExitCode wxThread::Wait(wxThreadWait waitMode)
1135 {
1136 ExitCode rc = wxUIntToPtr(THREAD_ERROR_EXIT);
1137
1138 // although under Windows we can wait for any thread, it's an error to
1139 // wait for a detached one in wxWin API
1140 wxCHECK_MSG( !IsDetached(), rc,
1141 wxT("wxThread::Wait(): can't wait for detached thread") );
1142
1143 (void)m_internal->WaitForTerminate(m_critsect, &rc, waitMode);
1144
1145 return rc;
1146 }
1147
1148 wxThreadError wxThread::Delete(ExitCode *pRc, wxThreadWait waitMode)
1149 {
1150 return m_internal->WaitForTerminate(m_critsect, pRc, waitMode, this);
1151 }
1152
1153 wxThreadError wxThread::Kill()
1154 {
1155 if ( !IsRunning() )
1156 return wxTHREAD_NOT_RUNNING;
1157
1158 wxThreadError rc = m_internal->Kill();
1159
1160 if ( IsDetached() )
1161 {
1162 delete this;
1163 }
1164 else // joinable
1165 {
1166 // update the status of the joinable thread
1167 wxCriticalSectionLocker lock(m_critsect);
1168 m_internal->SetState(STATE_EXITED);
1169 }
1170
1171 return rc;
1172 }
1173
1174 void wxThread::Exit(ExitCode status)
1175 {
1176 wxThreadInternal::DoThreadOnExit(this);
1177
1178 m_internal->Free();
1179
1180 if ( IsDetached() )
1181 {
1182 delete this;
1183 }
1184 else // joinable
1185 {
1186 // update the status of the joinable thread
1187 wxCriticalSectionLocker lock(m_critsect);
1188 m_internal->SetState(STATE_EXITED);
1189 }
1190
1191 #ifdef wxUSE_BEGIN_THREAD
1192 _endthreadex(wxPtrToUInt(status));
1193 #else // !VC++
1194 ::ExitThread((DWORD)status);
1195 #endif // VC++/!VC++
1196
1197 wxFAIL_MSG(wxT("Couldn't return from ExitThread()!"));
1198 }
1199
1200 // priority setting
1201 // ----------------
1202
1203 void wxThread::SetPriority(unsigned int prio)
1204 {
1205 wxCriticalSectionLocker lock(m_critsect);
1206
1207 m_internal->SetPriority(prio);
1208 }
1209
1210 unsigned int wxThread::GetPriority() const
1211 {
1212 wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
1213
1214 return m_internal->GetPriority();
1215 }
1216
1217 unsigned long wxThread::GetId() const
1218 {
1219 wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
1220
1221 return (unsigned long)m_internal->GetId();
1222 }
1223
1224 bool wxThread::IsRunning() const
1225 {
1226 wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
1227
1228 return m_internal->GetState() == STATE_RUNNING;
1229 }
1230
1231 bool wxThread::IsAlive() const
1232 {
1233 wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
1234
1235 return (m_internal->GetState() == STATE_RUNNING) ||
1236 (m_internal->GetState() == STATE_PAUSED);
1237 }
1238
1239 bool wxThread::IsPaused() const
1240 {
1241 wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
1242
1243 return m_internal->GetState() == STATE_PAUSED;
1244 }
1245
1246 bool wxThread::TestDestroy()
1247 {
1248 wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
1249
1250 return m_internal->GetState() == STATE_CANCELED;
1251 }
1252
1253 // ----------------------------------------------------------------------------
1254 // Automatic initialization for thread module
1255 // ----------------------------------------------------------------------------
1256
1257 class wxThreadModule : public wxModule
1258 {
1259 public:
1260 virtual bool OnInit();
1261 virtual void OnExit();
1262
1263 private:
1264 DECLARE_DYNAMIC_CLASS(wxThreadModule)
1265 };
1266
1267 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
1268
1269 bool wxThreadModule::OnInit()
1270 {
1271 // allocate TLS index for storing the pointer to the current thread
1272 gs_tlsThisThread = ::TlsAlloc();
1273 if ( gs_tlsThisThread == 0xFFFFFFFF )
1274 {
1275 // in normal circumstances it will only happen if all other
1276 // TLS_MINIMUM_AVAILABLE (>= 64) indices are already taken - in other
1277 // words, this should never happen
1278 wxLogSysError(_("Thread module initialization failed: impossible to allocate index in thread local storage"));
1279
1280 return false;
1281 }
1282
1283 // main thread doesn't have associated wxThread object, so store 0 in the
1284 // TLS instead
1285 if ( !::TlsSetValue(gs_tlsThisThread, (LPVOID)0) )
1286 {
1287 ::TlsFree(gs_tlsThisThread);
1288 gs_tlsThisThread = 0xFFFFFFFF;
1289
1290 wxLogSysError(_("Thread module initialization failed: cannot store value in thread local storage"));
1291
1292 return false;
1293 }
1294
1295 gs_critsectWaitingForGui = new wxCriticalSection();
1296
1297 gs_critsectGui = new wxCriticalSection();
1298 gs_critsectGui->Enter();
1299
1300 gs_critsectThreadDelete = new wxCriticalSection;
1301
1302 wxThread::ms_idMainThread = wxThread::GetCurrentId();
1303
1304 return true;
1305 }
1306
1307 void wxThreadModule::OnExit()
1308 {
1309 if ( !::TlsFree(gs_tlsThisThread) )
1310 {
1311 wxLogLastError(wxT("TlsFree failed."));
1312 }
1313
1314 wxDELETE(gs_critsectThreadDelete);
1315
1316 if ( gs_critsectGui )
1317 {
1318 gs_critsectGui->Leave();
1319 wxDELETE(gs_critsectGui);
1320 }
1321
1322 wxDELETE(gs_critsectWaitingForGui);
1323 }
1324
1325 // ----------------------------------------------------------------------------
1326 // under Windows, these functions are implemented using a critical section and
1327 // not a mutex, so the names are a bit confusing
1328 // ----------------------------------------------------------------------------
1329
1330 void wxMutexGuiEnterImpl()
1331 {
1332 // this would dead lock everything...
1333 wxASSERT_MSG( !wxThread::IsMain(),
1334 wxT("main thread doesn't want to block in wxMutexGuiEnter()!") );
1335
1336 // the order in which we enter the critical sections here is crucial!!
1337
1338 // set the flag telling to the main thread that we want to do some GUI
1339 {
1340 wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
1341
1342 gs_nWaitingForGui++;
1343 }
1344
1345 wxWakeUpMainThread();
1346
1347 // now we may block here because the main thread will soon let us in
1348 // (during the next iteration of OnIdle())
1349 gs_critsectGui->Enter();
1350 }
1351
1352 void wxMutexGuiLeaveImpl()
1353 {
1354 wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
1355
1356 if ( wxThread::IsMain() )
1357 {
1358 gs_bGuiOwnedByMainThread = false;
1359 }
1360 else
1361 {
1362 // decrement the number of threads waiting for GUI access now
1363 wxASSERT_MSG( gs_nWaitingForGui > 0,
1364 wxT("calling wxMutexGuiLeave() without entering it first?") );
1365
1366 gs_nWaitingForGui--;
1367
1368 wxWakeUpMainThread();
1369 }
1370
1371 gs_critsectGui->Leave();
1372 }
1373
1374 void WXDLLIMPEXP_BASE wxMutexGuiLeaveOrEnter()
1375 {
1376 wxASSERT_MSG( wxThread::IsMain(),
1377 wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") );
1378
1379 wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
1380
1381 if ( gs_nWaitingForGui == 0 )
1382 {
1383 // no threads are waiting for GUI - so we may acquire the lock without
1384 // any danger (but only if we don't already have it)
1385 if ( !wxGuiOwnedByMainThread() )
1386 {
1387 gs_critsectGui->Enter();
1388
1389 gs_bGuiOwnedByMainThread = true;
1390 }
1391 //else: already have it, nothing to do
1392 }
1393 else
1394 {
1395 // some threads are waiting, release the GUI lock if we have it
1396 if ( wxGuiOwnedByMainThread() )
1397 {
1398 wxMutexGuiLeave();
1399 }
1400 //else: some other worker thread is doing GUI
1401 }
1402 }
1403
1404 bool WXDLLIMPEXP_BASE wxGuiOwnedByMainThread()
1405 {
1406 return gs_bGuiOwnedByMainThread;
1407 }
1408
1409 // wake up the main thread if it's in ::GetMessage()
1410 void WXDLLIMPEXP_BASE wxWakeUpMainThread()
1411 {
1412 // sending any message would do - hopefully WM_NULL is harmless enough
1413 if ( !::PostThreadMessage(wxThread::GetMainId(), WM_NULL, 0, 0) )
1414 {
1415 // should never happen
1416 wxLogLastError(wxT("PostThreadMessage(WM_NULL)"));
1417 }
1418 }
1419
1420 bool WXDLLIMPEXP_BASE wxIsWaitingForThread()
1421 {
1422 return gs_waitingForThread;
1423 }
1424
1425 // ----------------------------------------------------------------------------
1426 // include common implementation code
1427 // ----------------------------------------------------------------------------
1428
1429 #include "wx/thrimpl.cpp"
1430
1431 #endif // wxUSE_THREADS