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/msw/missing.h"
  30     #include "wx/intl.h"
  31     #include "wx/app.h"
  32     #include "wx/module.h"
  33 #endif
  34
  35 #include "wx/apptrait.h"
  36 #include "wx/scopeguard.h"
  37
  38 #include "wx/msw/private.h"
  39 #include "wx/msw/seh.h"
  40
  41 #include "wx/except.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 #if !defined(_WIN32_WCE) || (_WIN32_WCE >= 300)
 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 #if !defined(_WIN32_WCE) || (_WIN32_WCE >= 300)
 357     if ( !::ReleaseSemaphore(m_semaphore, 1, NULL /* ptr to previous count */) )
 358     {
 359         if ( GetLastError() == ERROR_TOO_MANY_POSTS )
 360         {
 361             return wxSEMA_OVERFLOW;
 362         }
 363         else
 364         {
 365             wxLogLastError(_T("ReleaseSemaphore"));
 366             return wxSEMA_MISC_ERROR;
 367         }
 368     }
 369
 370     return wxSEMA_NO_ERROR;
 371 #else
 372     return wxSEMA_MISC_ERROR;
 373 #endif
 374 }
 375
 376 // ----------------------------------------------------------------------------
 377 // wxThread implementation
 378 // ----------------------------------------------------------------------------
 379
 380 // wxThreadInternal class
 381 // ----------------------
 382
 383 class wxThreadInternal
 384 {
 385 public:
 386     wxThreadInternal(wxThread *thread)
 387     {
 388         m_thread = thread;
 389         m_hThread = 0;
 390         m_state = STATE_NEW;
 391         m_priority = WXTHREAD_DEFAULT_PRIORITY;
 392         m_nRef = 1;
 393     }
 394
 395     ~wxThreadInternal()
 396     {
 397         Free();
 398     }
 399
 400     void Free()
 401     {
 402         if ( m_hThread )
 403         {
 404             if ( !::CloseHandle(m_hThread) )
 405             {
 406                 wxLogLastError(wxT("CloseHandle(thread)"));
 407             }
 408
 409             m_hThread = 0;
 410         }
 411     }
 412
 413     // create a new (suspended) thread (for the given thread object)
 414     bool Create(wxThread *thread, unsigned int stackSize);
 415
 416     // wait for the thread to terminate, either by itself, or by asking it
 417     // (politely, this is not Kill()!) to do it
 418     wxThreadError WaitForTerminate(wxCriticalSection& cs,
 419                                    wxThread::ExitCode *pRc,
 420                                    wxThread *threadToDelete = NULL);
 421
 422     // kill the thread unconditionally
 423     wxThreadError Kill();
 424
 425     // suspend/resume/terminate
 426     bool Suspend();
 427     bool Resume();
 428     void Cancel() { m_state = STATE_CANCELED; }
 429
 430     // thread state
 431     void SetState(wxThreadState state) { m_state = state; }
 432     wxThreadState GetState() const { return m_state; }
 433
 434     // thread priority
 435     void SetPriority(unsigned int priority);
 436     unsigned int GetPriority() const { return m_priority; }
 437
 438     // thread handle and id
 439     HANDLE GetHandle() const { return m_hThread; }
 440     DWORD  GetId() const { return m_tid; }
 441
 442     // the thread function forwarding to DoThreadStart
 443     static THREAD_RETVAL THREAD_CALLCONV WinThreadStart(void *thread);
 444
 445     // really start the thread (if it's not already dead)
 446     static THREAD_RETVAL DoThreadStart(wxThread *thread);
 447
 448     // call OnExit() on the thread
 449     static void DoThreadOnExit(wxThread *thread);
 450
 451
 452     void KeepAlive()
 453     {
 454         if ( m_thread->IsDetached() )
 455             ::InterlockedIncrement(&m_nRef);
 456     }
 457
 458     void LetDie()
 459     {
 460         if ( m_thread->IsDetached() && !::InterlockedDecrement(&m_nRef) )
 461             delete m_thread;
 462     }
 463
 464 private:
 465     // the thread we're associated with
 466     wxThread *m_thread;
 467
 468     HANDLE        m_hThread;    // handle of the thread
 469     wxThreadState m_state;      // state, see wxThreadState enum
 470     unsigned int  m_priority;   // thread priority in "wx" units
 471     DWORD         m_tid;        // thread id
 472
 473     // number of threads which need this thread to remain alive, when the count
 474     // reaches 0 we kill the owning wxThread -- and die ourselves with it
 475     LONG m_nRef;
 476
 477     DECLARE_NO_COPY_CLASS(wxThreadInternal)
 478 };
 479
 480 // small class which keeps a thread alive during its lifetime
 481 class wxThreadKeepAlive
 482 {
 483 public:
 484     wxThreadKeepAlive(wxThreadInternal& thrImpl) : m_thrImpl(thrImpl)
 485         { m_thrImpl.KeepAlive(); }
 486     ~wxThreadKeepAlive()
 487         { m_thrImpl.LetDie(); }
 488
 489 private:
 490     wxThreadInternal& m_thrImpl;
 491 };
 492
 493 /* static */
 494 void wxThreadInternal::DoThreadOnExit(wxThread *thread)
 495 {
 496     wxTRY
 497     {
 498         thread->OnExit();
 499     }
 500     wxCATCH_ALL( wxTheApp->OnUnhandledException(); )
 501 }
 502
 503 /* static */
 504 THREAD_RETVAL wxThreadInternal::DoThreadStart(wxThread *thread)
 505 {
 506     wxON_BLOCK_EXIT1(DoThreadOnExit, thread);
 507
 508     THREAD_RETVAL rc = (THREAD_RETVAL)-1;
 509
 510     wxTRY
 511     {
 512         // store the thread object in the TLS
 513         if ( !::TlsSetValue(gs_tlsThisThread, thread) )
 514         {
 515             wxLogSysError(_("Can not start thread: error writing TLS."));
 516
 517             return (THREAD_RETVAL)-1;
 518         }
 519
 520         rc = (THREAD_RETVAL)thread->Entry();
 521     }
 522     wxCATCH_ALL( wxTheApp->OnUnhandledException(); )
 523
 524     return rc;
 525 }
 526
 527 /* static */
 528 THREAD_RETVAL THREAD_CALLCONV wxThreadInternal::WinThreadStart(void *param)
 529 {
 530     THREAD_RETVAL rc = (THREAD_RETVAL)-1;
 531
 532     wxThread * const thread = (wxThread *)param;
 533
 534     // each thread has its own SEH translator so install our own a.s.a.p.
 535     DisableAutomaticSETranslator();
 536
 537     // first of all, check whether we hadn't been cancelled already and don't
 538     // start the user code at all then
 539     const bool hasExited = thread->m_internal->GetState() == STATE_EXITED;
 540
 541     // run the thread function itself inside a SEH try/except block
 542     wxSEH_TRY
 543     {
 544         if ( hasExited )
 545             DoThreadOnExit(thread);
 546         else
 547             rc = DoThreadStart(thread);
 548     }
 549     wxSEH_HANDLE((THREAD_RETVAL)-1)
 550
 551
 552     // save IsDetached because thread object can be deleted by joinable
 553     // threads after state is changed to STATE_EXITED.
 554     const bool isDetached = thread->IsDetached();
 555     if ( !hasExited )
 556     {
 557         // enter m_critsect before changing the thread state
 558         //
 559         // NB: can't use wxCriticalSectionLocker here as we use SEH and it's
 560         //     incompatible with C++ object dtors
 561         thread->m_critsect.Enter();
 562         thread->m_internal->SetState(STATE_EXITED);
 563         thread->m_critsect.Leave();
 564     }
 565
 566     // the thread may delete itself now if it wants, we don't need it any more
 567     if ( isDetached )
 568         thread->m_internal->LetDie();
 569
 570     return rc;
 571 }
 572
 573 void wxThreadInternal::SetPriority(unsigned int priority)
 574 {
 575     m_priority = priority;
 576
 577     // translate wxWidgets priority to the Windows one
 578     int win_priority;
 579     if (m_priority <= 20)
 580         win_priority = THREAD_PRIORITY_LOWEST;
 581     else if (m_priority <= 40)
 582         win_priority = THREAD_PRIORITY_BELOW_NORMAL;
 583     else if (m_priority <= 60)
 584         win_priority = THREAD_PRIORITY_NORMAL;
 585     else if (m_priority <= 80)
 586         win_priority = THREAD_PRIORITY_ABOVE_NORMAL;
 587     else if (m_priority <= 100)
 588         win_priority = THREAD_PRIORITY_HIGHEST;
 589     else
 590     {
 591         wxFAIL_MSG(wxT("invalid value of thread priority parameter"));
 592         win_priority = THREAD_PRIORITY_NORMAL;
 593     }
 594
 595     if ( !::SetThreadPriority(m_hThread, win_priority) )
 596     {
 597         wxLogSysError(_("Can't set thread priority"));
 598     }
 599 }
 600
 601 bool wxThreadInternal::Create(wxThread *thread, unsigned int stackSize)
 602 {
 603     wxASSERT_MSG( m_state == STATE_NEW && !m_hThread,
 604                     _T("Create()ing thread twice?") );
 605
 606     // for compilers which have it, we should use C RTL function for thread
 607     // creation instead of Win32 API one because otherwise we will have memory
 608     // leaks if the thread uses C RTL (and most threads do)
 609 #ifdef wxUSE_BEGIN_THREAD
 610
 611     // Watcom is reported to not like 0 stack size (which means "use default"
 612     // for the other compilers and is also the default value for stackSize)
 613 #ifdef __WATCOMC__
 614     if ( !stackSize )
 615         stackSize = 10240;
 616 #endif // __WATCOMC__
 617
 618     m_hThread = (HANDLE)_beginthreadex
 619                         (
 620                           NULL,                             // default security
 621                           stackSize,
 622                           wxThreadInternal::WinThreadStart, // entry point
 623                           thread,
 624                           CREATE_SUSPENDED,
 625                           (unsigned int *)&m_tid
 626                         );
 627 #else // compiler doesn't have _beginthreadex
 628     m_hThread = ::CreateThread
 629                   (
 630                     NULL,                               // default security
 631                     stackSize,                          // stack size
 632                     wxThreadInternal::WinThreadStart,   // thread entry point
 633                     (LPVOID)thread,                     // parameter
 634                     CREATE_SUSPENDED,                   // flags
 635                     &m_tid                              // [out] thread id
 636                   );
 637 #endif // _beginthreadex/CreateThread
 638
 639     if ( m_hThread == NULL )
 640     {
 641         wxLogSysError(_("Can't create thread"));
 642
 643         return false;
 644     }
 645
 646     if ( m_priority != WXTHREAD_DEFAULT_PRIORITY )
 647     {
 648         SetPriority(m_priority);
 649     }
 650
 651     return true;
 652 }
 653
 654 wxThreadError wxThreadInternal::Kill()
 655 {
 656     if ( !::TerminateThread(m_hThread, (DWORD)-1) )
 657     {
 658         wxLogSysError(_("Couldn't terminate thread"));
 659
 660         return wxTHREAD_MISC_ERROR;
 661     }
 662
 663     Free();
 664
 665     return wxTHREAD_NO_ERROR;
 666 }
 667
 668 wxThreadError
 669 wxThreadInternal::WaitForTerminate(wxCriticalSection& cs,
 670                                    wxThread::ExitCode *pRc,
 671                                    wxThread *threadToDelete)
 672 {
 673     // prevent the thread C++ object from disappearing as long as we are using
 674     // it here
 675     wxThreadKeepAlive keepAlive(*this);
 676
 677
 678     // we may either wait passively for the thread to terminate (when called
 679     // from Wait()) or ask it to terminate (when called from Delete())
 680     bool shouldDelete = threadToDelete != NULL;
 681
 682     wxThread::ExitCode rc = 0;
 683
 684     // we might need to resume the thread if it's currently stopped
 685     bool shouldResume = false;
 686
 687     // as Delete() (which calls us) is always safe to call we need to consider
 688     // all possible states
 689     {
 690         wxCriticalSectionLocker lock(cs);
 691
 692         if ( m_state == STATE_NEW )
 693         {
 694             if ( shouldDelete )
 695             {
 696                 // WinThreadStart() will see it and terminate immediately, no
 697                 // need to cancel the thread -- but we still need to resume it
 698                 // to let it run
 699                 m_state = STATE_EXITED;
 700
 701                 // we must call Resume() as the thread hasn't been initially
 702                 // resumed yet (and as Resume() it knows about STATE_EXITED
 703                 // special case, it won't touch it and WinThreadStart() will
 704                 // just exit immediately)
 705                 shouldResume = true;
 706                 shouldDelete = false;
 707             }
 708             //else: shouldResume is correctly set to false here, wait until
 709             //      someone else runs the thread and it finishes
 710         }
 711         else // running, paused, cancelled or even exited
 712         {
 713             shouldResume = m_state == STATE_PAUSED;
 714         }
 715     }
 716
 717     // resume the thread if it is paused
 718     if ( shouldResume )
 719         Resume();
 720
 721     // ask the thread to terminate
 722     if ( shouldDelete )
 723     {
 724         wxCriticalSectionLocker lock(cs);
 725
 726         Cancel();
 727     }
 728
 729
 730     // now wait for thread to finish
 731     if ( wxThread::IsMain() )
 732     {
 733         // set flag for wxIsWaitingForThread()
 734         gs_waitingForThread = true;
 735     }
 736
 737     // we can't just wait for the thread to terminate because it might be
 738     // calling some GUI functions and so it will never terminate before we
 739     // process the Windows messages that result from these functions
 740     // (note that even in console applications we might have to process
 741     // messages if we use wxExecute() or timers or ...)
 742     DWORD result wxDUMMY_INITIALIZE(0);
 743     do
 744     {
 745         if ( wxThread::IsMain() )
 746         {
 747             // give the thread we're waiting for chance to do the GUI call
 748             // it might be in
 749             if ( (gs_nWaitingForGui > 0) && wxGuiOwnedByMainThread() )
 750             {
 751                 wxMutexGuiLeave();
 752             }
 753         }
 754
 755 #if !defined(QS_ALLPOSTMESSAGE)
 756 #define QS_ALLPOSTMESSAGE 0
 757 #endif
 758         wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
 759         if ( traits )
 760         {
 761             result = traits->WaitForThread(m_hThread);
 762         }
 763         else // can't wait for the thread
 764         {
 765             // so kill it below
 766             result = 0xFFFFFFFF;
 767         }
 768
 769         switch ( result )
 770         {
 771             case 0xFFFFFFFF:
 772                 // error
 773                 wxLogSysError(_("Can not wait for thread termination"));
 774                 Kill();
 775                 return wxTHREAD_KILLED;
 776
 777             case WAIT_OBJECT_0:
 778                 // thread we're waiting for terminated
 779                 break;
 780
 781             case WAIT_OBJECT_0 + 1:
 782                 // new message arrived, process it -- but only if we're the
 783                 // main thread as we don't support processing messages in
 784                 // the other ones
 785                 //
 786                 // NB: we still must include QS_ALLINPUT even when waiting
 787                 //     in a secondary thread because if it had created some
 788                 //     window somehow (possible not even using wxWidgets)
 789                 //     the system might dead lock then
 790                 if ( wxThread::IsMain() )
 791                 {
 792                     if ( traits && !traits->DoMessageFromThreadWait() )
 793                     {
 794                         // WM_QUIT received: kill the thread
 795                         Kill();
 796
 797                         return wxTHREAD_KILLED;
 798                     }
 799                 }
 800                 break;
 801
 802             default:
 803                 wxFAIL_MSG(wxT("unexpected result of MsgWaitForMultipleObject"));
 804         }
 805     } while ( result != WAIT_OBJECT_0 );
 806
 807     if ( wxThread::IsMain() )
 808     {
 809         gs_waitingForThread = false;
 810     }
 811
 812
 813     // although the thread might be already in the EXITED state it might not
 814     // have terminated yet and so we are not sure that it has actually
 815     // terminated if the "if" above hadn't been taken
 816     for ( ;; )
 817     {
 818         if ( !::GetExitCodeThread(m_hThread, (LPDWORD)&rc) )
 819         {
 820             wxLogLastError(wxT("GetExitCodeThread"));
 821
 822             rc = (wxThread::ExitCode)-1;
 823
 824             break;
 825         }
 826
 827         if ( (DWORD)rc != STILL_ACTIVE )
 828             break;
 829
 830         // give the other thread some time to terminate, otherwise we may be
 831         // starving it
 832         ::Sleep(1);
 833     }
 834
 835     if ( pRc )
 836         *pRc = rc;
 837
 838     // we don't need the thread handle any more in any case
 839     Free();
 840
 841
 842     return rc == (wxThread::ExitCode)-1 ? wxTHREAD_MISC_ERROR
 843                                         : wxTHREAD_NO_ERROR;
 844 }
 845
 846 bool wxThreadInternal::Suspend()
 847 {
 848     DWORD nSuspendCount = ::SuspendThread(m_hThread);
 849     if ( nSuspendCount == (DWORD)-1 )
 850     {
 851         wxLogSysError(_("Can not suspend thread %x"), m_hThread);
 852
 853         return false;
 854     }
 855
 856     m_state = STATE_PAUSED;
 857
 858     return true;
 859 }
 860
 861 bool wxThreadInternal::Resume()
 862 {
 863     DWORD nSuspendCount = ::ResumeThread(m_hThread);
 864     if ( nSuspendCount == (DWORD)-1 )
 865     {
 866         wxLogSysError(_("Can not resume thread %x"), m_hThread);
 867
 868         return false;
 869     }
 870
 871     // don't change the state from STATE_EXITED because it's special and means
 872     // we are going to terminate without running any user code - if we did it,
 873     // the code in WaitForTerminate() wouldn't work
 874     if ( m_state != STATE_EXITED )
 875     {
 876         m_state = STATE_RUNNING;
 877     }
 878
 879     return true;
 880 }
 881
 882 // static functions
 883 // ----------------
 884
 885 wxThread *wxThread::This()
 886 {
 887     wxThread *thread = (wxThread *)::TlsGetValue(gs_tlsThisThread);
 888
 889     // be careful, 0 may be a valid return value as well
 890     if ( !thread && (::GetLastError() != NO_ERROR) )
 891     {
 892         wxLogSysError(_("Couldn't get the current thread pointer"));
 893
 894         // return NULL...
 895     }
 896
 897     return thread;
 898 }
 899
 900 bool wxThread::IsMain()
 901 {
 902     return ::GetCurrentThreadId() == gs_idMainThread || gs_idMainThread == 0;
 903 }
 904
 905 void wxThread::Yield()
 906 {
 907     // 0 argument to Sleep() is special and means to just give away the rest of
 908     // our timeslice
 909     ::Sleep(0);
 910 }
 911
 912 void wxThread::Sleep(unsigned long milliseconds)
 913 {
 914     ::Sleep(milliseconds);
 915 }
 916
 917 int wxThread::GetCPUCount()
 918 {
 919     SYSTEM_INFO si;
 920     GetSystemInfo(&si);
 921
 922     return si.dwNumberOfProcessors;
 923 }
 924
 925 unsigned long wxThread::GetCurrentId()
 926 {
 927     return (unsigned long)::GetCurrentThreadId();
 928 }
 929
 930 bool wxThread::SetConcurrency(size_t WXUNUSED_IN_WINCE(level))
 931 {
 932 #ifdef __WXWINCE__
 933     return false;
 934 #else
 935     wxASSERT_MSG( IsMain(), _T("should only be called from the main thread") );
 936
 937     // ok only for the default one
 938     if ( level == 0 )
 939         return 0;
 940
 941     // get system affinity mask first
 942     HANDLE hProcess = ::GetCurrentProcess();
 943     DWORD_PTR dwProcMask, dwSysMask;
 944     if ( ::GetProcessAffinityMask(hProcess, &dwProcMask, &dwSysMask) == 0 )
 945     {
 946         wxLogLastError(_T("GetProcessAffinityMask"));
 947
 948         return false;
 949     }
 950
 951     // how many CPUs have we got?
 952     if ( dwSysMask == 1 )
 953     {
 954         // don't bother with all this complicated stuff - on a single
 955         // processor system it doesn't make much sense anyhow
 956         return level == 1;
 957     }
 958
 959     // calculate the process mask: it's a bit vector with one bit per
 960     // processor; we want to schedule the process to run on first level
 961     // CPUs
 962     DWORD bit = 1;
 963     while ( bit )
 964     {
 965         if ( dwSysMask & bit )
 966         {
 967             // ok, we can set this bit
 968             dwProcMask |= bit;
 969
 970             // another process added
 971             if ( --level == 0 )
 972             {
 973                 // and that's enough
 974                 break;
 975             }
 976         }
 977
 978         // next bit
 979         bit <<= 1;
 980     }
 981
 982     // could we set all bits?
 983     if ( level != 0 )
 984     {
 985         wxLogDebug(_T("bad level %u in wxThread::SetConcurrency()"), level);
 986
 987         return false;
 988     }
 989
 990     // set it: we can't link to SetProcessAffinityMask() because it doesn't
 991     // exist in Win9x, use RT binding instead
 992
 993     typedef BOOL (*SETPROCESSAFFINITYMASK)(HANDLE, DWORD);
 994
 995     // can use static var because we're always in the main thread here
 996     static SETPROCESSAFFINITYMASK pfnSetProcessAffinityMask = NULL;
 997
 998     if ( !pfnSetProcessAffinityMask )
 999     {
1000         HMODULE hModKernel = ::LoadLibrary(_T("kernel32"));
1001         if ( hModKernel )
1002         {
1003             pfnSetProcessAffinityMask = (SETPROCESSAFFINITYMASK)
1004                 ::GetProcAddress(hModKernel, "SetProcessAffinityMask");
1005         }
1006
1007         // we've discovered a MT version of Win9x!
1008         wxASSERT_MSG( pfnSetProcessAffinityMask,
1009                       _T("this system has several CPUs but no SetProcessAffinityMask function?") );
1010     }
1011
1012     if ( !pfnSetProcessAffinityMask )
1013     {
1014         // msg given above - do it only once
1015         return false;
1016     }
1017
1018     if ( pfnSetProcessAffinityMask(hProcess, dwProcMask) == 0 )
1019     {
1020         wxLogLastError(_T("SetProcessAffinityMask"));
1021
1022         return false;
1023     }
1024
1025     return true;
1026 #endif // __WXWINCE__/!__WXWINCE__
1027 }
1028
1029 // ctor and dtor
1030 // -------------
1031
1032 wxThread::wxThread(wxThreadKind kind)
1033 {
1034     m_internal = new wxThreadInternal(this);
1035
1036     m_isDetached = kind == wxTHREAD_DETACHED;
1037 }
1038
1039 wxThread::~wxThread()
1040 {
1041     delete m_internal;
1042 }
1043
1044 // create/start thread
1045 // -------------------
1046
1047 wxThreadError wxThread::Create(unsigned int stackSize)
1048 {
1049     wxCriticalSectionLocker lock(m_critsect);
1050
1051     if ( !m_internal->Create(this, stackSize) )
1052         return wxTHREAD_NO_RESOURCE;
1053
1054     return wxTHREAD_NO_ERROR;
1055 }
1056
1057 wxThreadError wxThread::Run()
1058 {
1059     wxCriticalSectionLocker lock(m_critsect);
1060
1061     if ( m_internal->GetState() != STATE_NEW )
1062     {
1063         // actually, it may be almost any state at all, not only STATE_RUNNING
1064         return wxTHREAD_RUNNING;
1065     }
1066
1067     // the thread has just been created and is still suspended - let it run
1068     return Resume();
1069 }
1070
1071 // suspend/resume thread
1072 // ---------------------
1073
1074 wxThreadError wxThread::Pause()
1075 {
1076     wxCriticalSectionLocker lock(m_critsect);
1077
1078     return m_internal->Suspend() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
1079 }
1080
1081 wxThreadError wxThread::Resume()
1082 {
1083     wxCriticalSectionLocker lock(m_critsect);
1084
1085     return m_internal->Resume() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
1086 }
1087
1088 // stopping thread
1089 // ---------------
1090
1091 wxThread::ExitCode wxThread::Wait()
1092 {
1093     // although under Windows we can wait for any thread, it's an error to
1094     // wait for a detached one in wxWin API
1095     wxCHECK_MSG( !IsDetached(), (ExitCode)-1,
1096                  _T("wxThread::Wait(): can't wait for detached thread") );
1097
1098     ExitCode rc = (ExitCode)-1;
1099
1100     (void)m_internal->WaitForTerminate(m_critsect, &rc);
1101
1102     return rc;
1103 }
1104
1105 wxThreadError wxThread::Delete(ExitCode *pRc)
1106 {
1107     return m_internal->WaitForTerminate(m_critsect, pRc, this);
1108 }
1109
1110 wxThreadError wxThread::Kill()
1111 {
1112     if ( !IsRunning() )
1113         return wxTHREAD_NOT_RUNNING;
1114
1115     wxThreadError rc = m_internal->Kill();
1116
1117     if ( IsDetached() )
1118     {
1119         delete this;
1120     }
1121     else // joinable
1122     {
1123         // update the status of the joinable thread
1124         wxCriticalSectionLocker lock(m_critsect);
1125         m_internal->SetState(STATE_EXITED);
1126     }
1127
1128     return rc;
1129 }
1130
1131 void wxThread::Exit(ExitCode status)
1132 {
1133     m_internal->Free();
1134
1135     if ( IsDetached() )
1136     {
1137         delete this;
1138     }
1139     else // joinable
1140     {
1141         // update the status of the joinable thread
1142         wxCriticalSectionLocker lock(m_critsect);
1143         m_internal->SetState(STATE_EXITED);
1144     }
1145
1146 #ifdef wxUSE_BEGIN_THREAD
1147     _endthreadex((unsigned)status);
1148 #else // !VC++
1149     ::ExitThread((DWORD)status);
1150 #endif // VC++/!VC++
1151
1152     wxFAIL_MSG(wxT("Couldn't return from ExitThread()!"));
1153 }
1154
1155 // priority setting
1156 // ----------------
1157
1158 void wxThread::SetPriority(unsigned int prio)
1159 {
1160     wxCriticalSectionLocker lock(m_critsect);
1161
1162     m_internal->SetPriority(prio);
1163 }
1164
1165 unsigned int wxThread::GetPriority() const
1166 {
1167     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1168
1169     return m_internal->GetPriority();
1170 }
1171
1172 unsigned long wxThread::GetId() const
1173 {
1174     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1175
1176     return (unsigned long)m_internal->GetId();
1177 }
1178
1179 bool wxThread::IsRunning() const
1180 {
1181     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1182
1183     return m_internal->GetState() == STATE_RUNNING;
1184 }
1185
1186 bool wxThread::IsAlive() const
1187 {
1188     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1189
1190     return (m_internal->GetState() == STATE_RUNNING) ||
1191            (m_internal->GetState() == STATE_PAUSED);
1192 }
1193
1194 bool wxThread::IsPaused() const
1195 {
1196     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1197
1198     return m_internal->GetState() == STATE_PAUSED;
1199 }
1200
1201 bool wxThread::TestDestroy()
1202 {
1203     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1204
1205     return m_internal->GetState() == STATE_CANCELED;
1206 }
1207
1208 // ----------------------------------------------------------------------------
1209 // Automatic initialization for thread module
1210 // ----------------------------------------------------------------------------
1211
1212 class wxThreadModule : public wxModule
1213 {
1214 public:
1215     virtual bool OnInit();
1216     virtual void OnExit();
1217
1218 private:
1219     DECLARE_DYNAMIC_CLASS(wxThreadModule)
1220 };
1221
1222 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
1223
1224 bool wxThreadModule::OnInit()
1225 {
1226     // allocate TLS index for storing the pointer to the current thread
1227     gs_tlsThisThread = ::TlsAlloc();
1228     if ( gs_tlsThisThread == 0xFFFFFFFF )
1229     {
1230         // in normal circumstances it will only happen if all other
1231         // TLS_MINIMUM_AVAILABLE (>= 64) indices are already taken - in other
1232         // words, this should never happen
1233         wxLogSysError(_("Thread module initialization failed: impossible to allocate index in thread local storage"));
1234
1235         return false;
1236     }
1237
1238     // main thread doesn't have associated wxThread object, so store 0 in the
1239     // TLS instead
1240     if ( !::TlsSetValue(gs_tlsThisThread, (LPVOID)0) )
1241     {
1242         ::TlsFree(gs_tlsThisThread);
1243         gs_tlsThisThread = 0xFFFFFFFF;
1244
1245         wxLogSysError(_("Thread module initialization failed: can not store value in thread local storage"));
1246
1247         return false;
1248     }
1249
1250     gs_critsectWaitingForGui = new wxCriticalSection();
1251
1252     gs_critsectGui = new wxCriticalSection();
1253     gs_critsectGui->Enter();
1254
1255     gs_critsectThreadDelete = new wxCriticalSection;
1256
1257     // no error return for GetCurrentThreadId()
1258     gs_idMainThread = ::GetCurrentThreadId();
1259
1260     return true;
1261 }
1262
1263 void wxThreadModule::OnExit()
1264 {
1265     if ( !::TlsFree(gs_tlsThisThread) )
1266     {
1267         wxLogLastError(wxT("TlsFree failed."));
1268     }
1269
1270     delete gs_critsectThreadDelete;
1271     gs_critsectThreadDelete = NULL;
1272
1273     if ( gs_critsectGui )
1274     {
1275         gs_critsectGui->Leave();
1276         delete gs_critsectGui;
1277         gs_critsectGui = NULL;
1278     }
1279
1280     delete gs_critsectWaitingForGui;
1281     gs_critsectWaitingForGui = NULL;
1282 }
1283
1284 // ----------------------------------------------------------------------------
1285 // under Windows, these functions are implemented using a critical section and
1286 // not a mutex, so the names are a bit confusing
1287 // ----------------------------------------------------------------------------
1288
1289 void WXDLLIMPEXP_BASE wxMutexGuiEnter()
1290 {
1291     // this would dead lock everything...
1292     wxASSERT_MSG( !wxThread::IsMain(),
1293                   wxT("main thread doesn't want to block in wxMutexGuiEnter()!") );
1294
1295     // the order in which we enter the critical sections here is crucial!!
1296
1297     // set the flag telling to the main thread that we want to do some GUI
1298     {
1299         wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
1300
1301         gs_nWaitingForGui++;
1302     }
1303
1304     wxWakeUpMainThread();
1305
1306     // now we may block here because the main thread will soon let us in
1307     // (during the next iteration of OnIdle())
1308     gs_critsectGui->Enter();
1309 }
1310
1311 void WXDLLIMPEXP_BASE wxMutexGuiLeave()
1312 {
1313     wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
1314
1315     if ( wxThread::IsMain() )
1316     {
1317         gs_bGuiOwnedByMainThread = false;
1318     }
1319     else
1320     {
1321         // decrement the number of threads waiting for GUI access now
1322         wxASSERT_MSG( gs_nWaitingForGui > 0,
1323                       wxT("calling wxMutexGuiLeave() without entering it first?") );
1324
1325         gs_nWaitingForGui--;
1326
1327         wxWakeUpMainThread();
1328     }
1329
1330     gs_critsectGui->Leave();
1331 }
1332
1333 void WXDLLIMPEXP_BASE wxMutexGuiLeaveOrEnter()
1334 {
1335     wxASSERT_MSG( wxThread::IsMain(),
1336                   wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") );
1337
1338     wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
1339
1340     if ( gs_nWaitingForGui == 0 )
1341     {
1342         // no threads are waiting for GUI - so we may acquire the lock without
1343         // any danger (but only if we don't already have it)
1344         if ( !wxGuiOwnedByMainThread() )
1345         {
1346             gs_critsectGui->Enter();
1347
1348             gs_bGuiOwnedByMainThread = true;
1349         }
1350         //else: already have it, nothing to do
1351     }
1352     else
1353     {
1354         // some threads are waiting, release the GUI lock if we have it
1355         if ( wxGuiOwnedByMainThread() )
1356         {
1357             wxMutexGuiLeave();
1358         }
1359         //else: some other worker thread is doing GUI
1360     }
1361 }
1362
1363 bool WXDLLIMPEXP_BASE wxGuiOwnedByMainThread()
1364 {
1365     return gs_bGuiOwnedByMainThread;
1366 }
1367
1368 // wake up the main thread if it's in ::GetMessage()
1369 void WXDLLIMPEXP_BASE wxWakeUpMainThread()
1370 {
1371     // sending any message would do - hopefully WM_NULL is harmless enough
1372     if ( !::PostThreadMessage(gs_idMainThread, WM_NULL, 0, 0) )
1373     {
1374         // should never happen
1375         wxLogLastError(wxT("PostThreadMessage(WM_NULL)"));
1376     }
1377 }
1378
1379 bool WXDLLIMPEXP_BASE wxIsWaitingForThread()
1380 {
1381     return gs_waitingForThread;
1382 }
1383
1384 // ----------------------------------------------------------------------------
1385 // include common implementation code
1386 // ----------------------------------------------------------------------------
1387
1388 #include "wx/thrimpl.cpp"
1389
1390 #endif // wxUSE_THREADS