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