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