src/msw/thread.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        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)
  10 // Licence:     wxWindows licence
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 #ifdef __GNUG__
  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/wx.h"
  30 #endif
  31
  32 #if wxUSE_THREADS
  33
  34 #include "wx/msw/private.h"
  35
  36 #include "wx/module.h"
  37 #include "wx/thread.h"
  38
  39 // must have this symbol defined to get _beginthread/_endthread declarations
  40 #ifndef _MT
  41     #define _MT
  42 #endif
  43
  44 #ifdef __VISUALC__
  45     #include <process.h>
  46 #endif
  47
  48 // ----------------------------------------------------------------------------
  49 // constants
  50 // ----------------------------------------------------------------------------
  51
  52 // the possible states of the thread ("=>" shows all possible transitions from
  53 // this state)
  54 enum wxThreadState
  55 {
  56     STATE_NEW,          // didn't start execution yet (=> RUNNING)
  57     STATE_RUNNING,      // thread is running (=> PAUSED, CANCELED)
  58     STATE_PAUSED,       // thread is temporarily suspended (=> RUNNING)
  59     STATE_CANCELED,     // thread should terminate a.s.a.p. (=> EXITED)
  60     STATE_EXITED        // thread is terminating
  61 };
  62
  63 // ----------------------------------------------------------------------------
  64 // this module globals
  65 // ----------------------------------------------------------------------------
  66
  67 // TLS index of the slot where we store the pointer to the current thread
  68 static DWORD gs_tlsThisThread = 0xFFFFFFFF;
  69
  70 // id of the main thread - the one which can call GUI functions without first
  71 // calling wxMutexGuiEnter()
  72 static DWORD gs_idMainThread = 0;
  73
  74 // if it's FALSE, some secondary thread is holding the GUI lock
  75 static bool gs_bGuiOwnedByMainThread = TRUE;
  76
  77 // critical section which controls access to all GUI functions: any secondary
  78 // thread (i.e. except the main one) must enter this crit section before doing
  79 // any GUI calls
  80 static wxCriticalSection *gs_critsectGui = NULL;
  81
  82 // critical section which protects gs_nWaitingForGui variable
  83 static wxCriticalSection *gs_critsectWaitingForGui = NULL;
  84
  85 // number of threads waiting for GUI in wxMutexGuiEnter()
  86 static size_t gs_nWaitingForGui = 0;
  87
  88 // are we waiting for a thread termination?
  89 static bool gs_waitingForThread = FALSE;
  90
  91 // ============================================================================
  92 // Windows implementation of thread classes
  93 // ============================================================================
  94
  95 // ----------------------------------------------------------------------------
  96 // wxMutex implementation
  97 // ----------------------------------------------------------------------------
  98
  99 class wxMutexInternal
 100 {
 101 public:
 102     HANDLE p_mutex;
 103 };
 104
 105 wxMutex::wxMutex()
 106 {
 107     m_internal = new wxMutexInternal;
 108     m_internal->p_mutex = CreateMutex(NULL, FALSE, NULL);
 109     if ( !m_internal->p_mutex )
 110     {
 111         wxLogSysError(_("Can not create mutex."));
 112     }
 113
 114     m_locked = 0;
 115 }
 116
 117 wxMutex::~wxMutex()
 118 {
 119     if (m_locked > 0)
 120         wxLogDebug(wxT("Warning: freeing a locked mutex (%d locks)."), m_locked);
 121     CloseHandle(m_internal->p_mutex);
 122 }
 123
 124 wxMutexError wxMutex::Lock()
 125 {
 126     DWORD ret;
 127
 128     ret = WaitForSingleObject(m_internal->p_mutex, INFINITE);
 129     switch ( ret )
 130     {
 131         case WAIT_ABANDONED:
 132             return wxMUTEX_BUSY;
 133
 134         case WAIT_OBJECT_0:
 135             // ok
 136             break;
 137
 138         case WAIT_FAILED:
 139             wxLogSysError(_("Couldn't acquire a mutex lock"));
 140             return wxMUTEX_MISC_ERROR;
 141
 142         case WAIT_TIMEOUT:
 143         default:
 144             wxFAIL_MSG(wxT("impossible return value in wxMutex::Lock"));
 145     }
 146
 147     m_locked++;
 148     return wxMUTEX_NO_ERROR;
 149 }
 150
 151 wxMutexError wxMutex::TryLock()
 152 {
 153     DWORD ret;
 154
 155     ret = WaitForSingleObject(m_internal->p_mutex, 0);
 156     if (ret == WAIT_TIMEOUT || ret == WAIT_ABANDONED)
 157         return wxMUTEX_BUSY;
 158
 159     m_locked++;
 160     return wxMUTEX_NO_ERROR;
 161 }
 162
 163 wxMutexError wxMutex::Unlock()
 164 {
 165     if (m_locked > 0)
 166         m_locked--;
 167
 168     BOOL ret = ReleaseMutex(m_internal->p_mutex);
 169     if ( ret == 0 )
 170     {
 171         wxLogSysError(_("Couldn't release a mutex"));
 172         return wxMUTEX_MISC_ERROR;
 173     }
 174
 175     return wxMUTEX_NO_ERROR;
 176 }
 177
 178 // ----------------------------------------------------------------------------
 179 // wxCondition implementation
 180 // ----------------------------------------------------------------------------
 181
 182 class wxConditionInternal
 183 {
 184 public:
 185     wxConditionInternal()
 186     {
 187         event = ::CreateEvent(
 188                               NULL,   // default secutiry
 189                               FALSE,  // not manual reset
 190                               FALSE,  // nonsignaled initially
 191                               NULL    // nameless event
 192                              );
 193         if ( !event )
 194         {
 195             wxLogSysError(_("Can not create event object."));
 196         }
 197         waiters = 0;
 198     }
 199
 200     bool Wait(DWORD timeout)
 201     {
 202         waiters++;
 203
 204         // FIXME this should be MsgWaitForMultipleObjects() as well probably
 205         DWORD rc = ::WaitForSingleObject(event, timeout);
 206
 207         waiters--;
 208
 209         return rc != WAIT_TIMEOUT;
 210     }
 211
 212     ~wxConditionInternal()
 213     {
 214         if ( event )
 215         {
 216             if ( !::CloseHandle(event) )
 217             {
 218                 wxLogLastError("CloseHandle(event)");
 219             }
 220         }
 221     }
 222
 223     HANDLE event;
 224     int waiters;
 225 };
 226
 227 wxCondition::wxCondition()
 228 {
 229     m_internal = new wxConditionInternal;
 230 }
 231
 232 wxCondition::~wxCondition()
 233 {
 234     delete m_internal;
 235 }
 236
 237 void wxCondition::Wait()
 238 {
 239     (void)m_internal->Wait(INFINITE);
 240 }
 241
 242 bool wxCondition::Wait(unsigned long sec,
 243                        unsigned long nsec)
 244 {
 245     return m_internal->Wait(sec*1000 + nsec/1000000);
 246 }
 247
 248 void wxCondition::Signal()
 249 {
 250     // set the event to signaled: if a thread is already waiting on it, it will
 251     // be woken up, otherwise the event will remain in the signaled state until
 252     // someone waits on it. In any case, the system will return it to a non
 253     // signalled state afterwards. If multiple threads are waiting, only one
 254     // will be woken up.
 255     if ( !::SetEvent(m_internal->event) )
 256     {
 257         wxLogLastError("SetEvent");
 258     }
 259 }
 260
 261 void wxCondition::Broadcast()
 262 {
 263     // this works because all these threads are already waiting and so each
 264     // SetEvent() inside Signal() is really a PulseEvent() because the event
 265     // state is immediately returned to non-signaled
 266     for ( int i = 0; i < m_internal->waiters; i++ )
 267     {
 268         Signal();
 269     }
 270 }
 271
 272 // ----------------------------------------------------------------------------
 273 // wxCriticalSection implementation
 274 // ----------------------------------------------------------------------------
 275
 276 wxCriticalSection::wxCriticalSection()
 277 {
 278     wxASSERT_MSG( sizeof(CRITICAL_SECTION) <= sizeof(m_buffer),
 279                   _T("must increase buffer size in wx/thread.h") );
 280
 281     ::InitializeCriticalSection((CRITICAL_SECTION *)m_buffer);
 282 }
 283
 284 wxCriticalSection::~wxCriticalSection()
 285 {
 286     ::DeleteCriticalSection((CRITICAL_SECTION *)m_buffer);
 287 }
 288
 289 void wxCriticalSection::Enter()
 290 {
 291     ::EnterCriticalSection((CRITICAL_SECTION *)m_buffer);
 292 }
 293
 294 void wxCriticalSection::Leave()
 295 {
 296     ::LeaveCriticalSection((CRITICAL_SECTION *)m_buffer);
 297 }
 298
 299 // ----------------------------------------------------------------------------
 300 // wxThread implementation
 301 // ----------------------------------------------------------------------------
 302
 303 // wxThreadInternal class
 304 // ----------------------
 305
 306 class wxThreadInternal
 307 {
 308 public:
 309     wxThreadInternal()
 310     {
 311         m_hThread = 0;
 312         m_state = STATE_NEW;
 313         m_priority = WXTHREAD_DEFAULT_PRIORITY;
 314     }
 315
 316     ~wxThreadInternal()
 317     {
 318         Free();
 319     }
 320
 321     void Free()
 322     {
 323         if ( m_hThread )
 324         {
 325             if ( !::CloseHandle(m_hThread) )
 326             {
 327                 wxLogLastError("CloseHandle(thread)");
 328             }
 329
 330             m_hThread = 0;
 331         }
 332     }
 333
 334     // create a new (suspended) thread (for the given thread object)
 335     bool Create(wxThread *thread);
 336
 337     // suspend/resume/terminate
 338     bool Suspend();
 339     bool Resume();
 340     void Cancel() { m_state = STATE_CANCELED; }
 341
 342     // thread state
 343     void SetState(wxThreadState state) { m_state = state; }
 344     wxThreadState GetState() const { return m_state; }
 345
 346     // thread priority
 347     void SetPriority(unsigned int priority);
 348     unsigned int GetPriority() const { return m_priority; }
 349
 350     // thread handle and id
 351     HANDLE GetHandle() const { return m_hThread; }
 352     DWORD  GetId() const { return m_tid; }
 353
 354     // thread function
 355     static DWORD WinThreadStart(wxThread *thread);
 356
 357 private:
 358     HANDLE        m_hThread;    // handle of the thread
 359     wxThreadState m_state;      // state, see wxThreadState enum
 360     unsigned int  m_priority;   // thread priority in "wx" units
 361     DWORD         m_tid;        // thread id
 362 };
 363
 364 DWORD wxThreadInternal::WinThreadStart(wxThread *thread)
 365 {
 366     // store the thread object in the TLS
 367     if ( !::TlsSetValue(gs_tlsThisThread, thread) )
 368     {
 369         wxLogSysError(_("Can not start thread: error writing TLS."));
 370
 371         return (DWORD)-1;
 372     }
 373
 374     DWORD rc = (DWORD)thread->Entry();
 375
 376     // enter m_critsect before changing the thread state
 377     thread->m_critsect.Enter();
 378     bool wasCancelled = thread->m_internal->GetState() == STATE_CANCELED;
 379     thread->m_internal->SetState(STATE_EXITED);
 380     thread->m_critsect.Leave();
 381
 382     thread->OnExit();
 383
 384     // if the thread was cancelled (from Delete()), then it the handle is still
 385     // needed there
 386     if ( thread->IsDetached() && !wasCancelled )
 387     {
 388         // auto delete
 389         delete thread;
 390     }
 391     //else: the joinable threads handle will be closed when Wait() is done
 392
 393     return rc;
 394 }
 395
 396 void wxThreadInternal::SetPriority(unsigned int priority)
 397 {
 398     m_priority = priority;
 399
 400     // translate wxWindows priority to the Windows one
 401     int win_priority;
 402     if (m_priority <= 20)
 403         win_priority = THREAD_PRIORITY_LOWEST;
 404     else if (m_priority <= 40)
 405         win_priority = THREAD_PRIORITY_BELOW_NORMAL;
 406     else if (m_priority <= 60)
 407         win_priority = THREAD_PRIORITY_NORMAL;
 408     else if (m_priority <= 80)
 409         win_priority = THREAD_PRIORITY_ABOVE_NORMAL;
 410     else if (m_priority <= 100)
 411         win_priority = THREAD_PRIORITY_HIGHEST;
 412     else
 413     {
 414         wxFAIL_MSG(wxT("invalid value of thread priority parameter"));
 415         win_priority = THREAD_PRIORITY_NORMAL;
 416     }
 417
 418     if ( !::SetThreadPriority(m_hThread, win_priority) )
 419     {
 420         wxLogSysError(_("Can't set thread priority"));
 421     }
 422 }
 423
 424 bool wxThreadInternal::Create(wxThread *thread)
 425 {
 426     // for compilers which have it, we should use C RTL function for thread
 427     // creation instead of Win32 API one because otherwise we will have memory
 428     // leaks if the thread uses C RTL (and most threads do)
 429 #ifdef __VISUALC__
 430     typedef unsigned (__stdcall *RtlThreadStart)(void *);
 431
 432     m_hThread = (HANDLE)_beginthreadex(NULL, 0,
 433                                        (RtlThreadStart)
 434                                        wxThreadInternal::WinThreadStart,
 435                                        thread, CREATE_SUSPENDED,
 436                                        (unsigned int *)&m_tid);
 437 #else // !VC++
 438     m_hThread = ::CreateThread
 439                   (
 440                     NULL,                               // default security
 441                     0,                                  // default stack size
 442                     (LPTHREAD_START_ROUTINE)            // thread entry point
 443                     wxThreadInternal::WinThreadStart,   //
 444                     (LPVOID)thread,                     // parameter
 445                     CREATE_SUSPENDED,                   // flags
 446                     &m_tid                              // [out] thread id
 447                   );
 448 #endif // VC++/!VC++
 449
 450     if ( m_hThread == NULL )
 451     {
 452         wxLogSysError(_("Can't create thread"));
 453
 454         return FALSE;
 455     }
 456
 457     if ( m_priority != WXTHREAD_DEFAULT_PRIORITY )
 458     {
 459         SetPriority(m_priority);
 460     }
 461
 462     return TRUE;
 463 }
 464
 465 bool wxThreadInternal::Suspend()
 466 {
 467     DWORD nSuspendCount = ::SuspendThread(m_hThread);
 468     if ( nSuspendCount == (DWORD)-1 )
 469     {
 470         wxLogSysError(_("Can not suspend thread %x"), m_hThread);
 471
 472         return FALSE;
 473     }
 474
 475     m_state = STATE_PAUSED;
 476
 477     return TRUE;
 478 }
 479
 480 bool wxThreadInternal::Resume()
 481 {
 482     DWORD nSuspendCount = ::ResumeThread(m_hThread);
 483     if ( nSuspendCount == (DWORD)-1 )
 484     {
 485         wxLogSysError(_("Can not resume thread %x"), m_hThread);
 486
 487         return FALSE;
 488     }
 489
 490     m_state = STATE_RUNNING;
 491
 492     return TRUE;
 493 }
 494
 495 // static functions
 496 // ----------------
 497
 498 wxThread *wxThread::This()
 499 {
 500     wxThread *thread = (wxThread *)::TlsGetValue(gs_tlsThisThread);
 501
 502     // be careful, 0 may be a valid return value as well
 503     if ( !thread && (::GetLastError() != NO_ERROR) )
 504     {
 505         wxLogSysError(_("Couldn't get the current thread pointer"));
 506
 507         // return NULL...
 508     }
 509
 510     return thread;
 511 }
 512
 513 bool wxThread::IsMain()
 514 {
 515     return ::GetCurrentThreadId() == gs_idMainThread;
 516 }
 517
 518 void wxThread::Yield()
 519 {
 520     // 0 argument to Sleep() is special and means to just give away the rest of
 521     // our timeslice
 522     ::Sleep(0);
 523 }
 524
 525 void wxThread::Sleep(unsigned long milliseconds)
 526 {
 527     ::Sleep(milliseconds);
 528 }
 529
 530 // ctor and dtor
 531 // -------------
 532
 533 wxThread::wxThread(wxThreadKind kind)
 534 {
 535     m_internal = new wxThreadInternal();
 536
 537     m_isDetached = kind == wxTHREAD_DETACHED;
 538 }
 539
 540 wxThread::~wxThread()
 541 {
 542     delete m_internal;
 543 }
 544
 545 // create/start thread
 546 // -------------------
 547
 548 wxThreadError wxThread::Create()
 549 {
 550     wxCriticalSectionLocker lock(m_critsect);
 551
 552     if ( !m_internal->Create(this) )
 553         return wxTHREAD_NO_RESOURCE;
 554
 555     return wxTHREAD_NO_ERROR;
 556 }
 557
 558 wxThreadError wxThread::Run()
 559 {
 560     wxCriticalSectionLocker lock(m_critsect);
 561
 562     if ( m_internal->GetState() != STATE_NEW )
 563     {
 564         // actually, it may be almost any state at all, not only STATE_RUNNING
 565         return wxTHREAD_RUNNING;
 566     }
 567
 568     // the thread has just been created and is still suspended - let it run
 569     return Resume();
 570 }
 571
 572 // suspend/resume thread
 573 // ---------------------
 574
 575 wxThreadError wxThread::Pause()
 576 {
 577     wxCriticalSectionLocker lock(m_critsect);
 578
 579     return m_internal->Suspend() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
 580 }
 581
 582 wxThreadError wxThread::Resume()
 583 {
 584     wxCriticalSectionLocker lock(m_critsect);
 585
 586     return m_internal->Resume() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
 587 }
 588
 589 // stopping thread
 590 // ---------------
 591
 592 wxThread::ExitCode wxThread::Wait()
 593 {
 594     // although under Windows we can wait for any thread, it's an error to
 595     // wait for a detached one in wxWin API
 596     wxCHECK_MSG( !IsDetached(), (ExitCode)-1,
 597                  _T("can't wait for detached thread") );
 598
 599     ExitCode rc = (ExitCode)-1;
 600
 601     (void)Delete(&rc);
 602
 603     m_internal->Free();
 604
 605     return rc;
 606 }
 607
 608 wxThreadError wxThread::Delete(ExitCode *pRc)
 609 {
 610     ExitCode rc = 0;
 611
 612     // Delete() is always safe to call, so consider all possible states
 613     if ( IsPaused() )
 614         Resume();
 615
 616     HANDLE hThread = m_internal->GetHandle();
 617
 618     if ( IsRunning() )
 619     {
 620         if ( IsMain() )
 621         {
 622             // set flag for wxIsWaitingForThread()
 623             gs_waitingForThread = TRUE;
 624
 625 #if wxUSE_GUI
 626             wxBeginBusyCursor();
 627 #endif // wxUSE_GUI
 628         }
 629
 630         // ask the thread to terminate
 631         {
 632             wxCriticalSectionLocker lock(m_critsect);
 633
 634             m_internal->Cancel();
 635         }
 636
 637 #if wxUSE_GUI
 638         // we can't just wait for the thread to terminate because it might be
 639         // calling some GUI functions and so it will never terminate before we
 640         // process the Windows messages that result from these functions
 641         DWORD result;
 642         do
 643         {
 644             result = ::MsgWaitForMultipleObjects
 645                      (
 646                        1,              // number of objects to wait for
 647                        &hThread,       // the objects
 648                        FALSE,          // don't wait for all objects
 649                        INFINITE,       // no timeout
 650                        QS_ALLEVENTS    // return as soon as there are any events
 651                      );
 652
 653             switch ( result )
 654             {
 655                 case 0xFFFFFFFF:
 656                     // error
 657                     wxLogSysError(_("Can not wait for thread termination"));
 658                     Kill();
 659                     return wxTHREAD_KILLED;
 660
 661                 case WAIT_OBJECT_0:
 662                     // thread we're waiting for terminated
 663                     break;
 664
 665                 case WAIT_OBJECT_0 + 1:
 666                     // new message arrived, process it
 667                     if ( !wxTheApp->DoMessage() )
 668                     {
 669                         // WM_QUIT received: kill the thread
 670                         Kill();
 671
 672                         return wxTHREAD_KILLED;
 673                     }
 674
 675                     if ( IsMain() )
 676                     {
 677                         // give the thread we're waiting for chance to exit
 678                         // from the GUI call it might have been in
 679                         if ( (gs_nWaitingForGui > 0) && wxGuiOwnedByMainThread() )
 680                         {
 681                             wxMutexGuiLeave();
 682                         }
 683                     }
 684
 685                     break;
 686
 687                 default:
 688                     wxFAIL_MSG(wxT("unexpected result of MsgWaitForMultipleObject"));
 689             }
 690         } while ( result != WAIT_OBJECT_0 );
 691 #else // !wxUSE_GUI
 692         // simply wait for the thread to terminate
 693         //
 694         // OTOH, even console apps create windows (in wxExecute, for WinSock
 695         // &c), so may be use MsgWaitForMultipleObject() too here?
 696         if ( WaitForSingleObject(hThread, INFINITE) != WAIT_OBJECT_0 )
 697         {
 698             wxFAIL_MSG(wxT("unexpected result of WaitForSingleObject"));
 699         }
 700 #endif // wxUSE_GUI/!wxUSE_GUI
 701
 702         if ( IsMain() )
 703         {
 704             gs_waitingForThread = FALSE;
 705
 706 #if wxUSE_GUI
 707             wxEndBusyCursor();
 708 #endif // wxUSE_GUI
 709         }
 710     }
 711
 712     if ( !::GetExitCodeThread(hThread, (LPDWORD)&rc) )
 713     {
 714         wxLogLastError("GetExitCodeThread");
 715
 716         rc = (ExitCode)-1;
 717     }
 718
 719     if ( IsDetached() )
 720     {
 721         // if the thread exits normally, this is done in WinThreadStart, but in
 722         // this case it would have been too early because
 723         // MsgWaitForMultipleObject() would fail if the therad handle was
 724         // closed while we were waiting on it, so we must do it here
 725         delete this;
 726     }
 727
 728     wxASSERT_MSG( (DWORD)rc != STILL_ACTIVE,
 729                   wxT("thread must be already terminated.") );
 730
 731     if ( pRc )
 732         *pRc = rc;
 733
 734     return rc == (ExitCode)-1 ? wxTHREAD_MISC_ERROR : wxTHREAD_NO_ERROR;
 735 }
 736
 737 wxThreadError wxThread::Kill()
 738 {
 739     if ( !IsRunning() )
 740         return wxTHREAD_NOT_RUNNING;
 741
 742     if ( !::TerminateThread(m_internal->GetHandle(), (DWORD)-1) )
 743     {
 744         wxLogSysError(_("Couldn't terminate thread"));
 745
 746         return wxTHREAD_MISC_ERROR;
 747     }
 748
 749     m_internal->Free();
 750
 751     if ( IsDetached() )
 752     {
 753         delete this;
 754     }
 755
 756     return wxTHREAD_NO_ERROR;
 757 }
 758
 759 void wxThread::Exit(ExitCode status)
 760 {
 761     m_internal->Free();
 762
 763     if ( IsDetached() )
 764     {
 765         delete this;
 766     }
 767
 768 #ifdef __VISUALC__
 769     _endthreadex((unsigned)status);
 770 #else // !VC++
 771     ::ExitThread((DWORD)status);
 772 #endif // VC++/!VC++
 773
 774     wxFAIL_MSG(wxT("Couldn't return from ExitThread()!"));
 775 }
 776
 777 // priority setting
 778 // ----------------
 779
 780 void wxThread::SetPriority(unsigned int prio)
 781 {
 782     wxCriticalSectionLocker lock(m_critsect);
 783
 784     m_internal->SetPriority(prio);
 785 }
 786
 787 unsigned int wxThread::GetPriority() const
 788 {
 789     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
 790
 791     return m_internal->GetPriority();
 792 }
 793
 794 unsigned long wxThread::GetId() const
 795 {
 796     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
 797
 798     return (unsigned long)m_internal->GetId();
 799 }
 800
 801 bool wxThread::IsRunning() const
 802 {
 803     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
 804
 805     return m_internal->GetState() == STATE_RUNNING;
 806 }
 807
 808 bool wxThread::IsAlive() const
 809 {
 810     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
 811
 812     return (m_internal->GetState() == STATE_RUNNING) ||
 813            (m_internal->GetState() == STATE_PAUSED);
 814 }
 815
 816 bool wxThread::IsPaused() const
 817 {
 818     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
 819
 820     return m_internal->GetState() == STATE_PAUSED;
 821 }
 822
 823 bool wxThread::TestDestroy()
 824 {
 825     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
 826
 827     return m_internal->GetState() == STATE_CANCELED;
 828 }
 829
 830 // ----------------------------------------------------------------------------
 831 // Automatic initialization for thread module
 832 // ----------------------------------------------------------------------------
 833
 834 class wxThreadModule : public wxModule
 835 {
 836 public:
 837     virtual bool OnInit();
 838     virtual void OnExit();
 839
 840 private:
 841     DECLARE_DYNAMIC_CLASS(wxThreadModule)
 842 };
 843
 844 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
 845
 846 bool wxThreadModule::OnInit()
 847 {
 848     // allocate TLS index for storing the pointer to the current thread
 849     gs_tlsThisThread = ::TlsAlloc();
 850     if ( gs_tlsThisThread == 0xFFFFFFFF )
 851     {
 852         // in normal circumstances it will only happen if all other
 853         // TLS_MINIMUM_AVAILABLE (>= 64) indices are already taken - in other
 854         // words, this should never happen
 855         wxLogSysError(_("Thread module initialization failed: "
 856                         "impossible to allocate index in thread "
 857                         "local storage"));
 858
 859         return FALSE;
 860     }
 861
 862     // main thread doesn't have associated wxThread object, so store 0 in the
 863     // TLS instead
 864     if ( !::TlsSetValue(gs_tlsThisThread, (LPVOID)0) )
 865     {
 866         ::TlsFree(gs_tlsThisThread);
 867         gs_tlsThisThread = 0xFFFFFFFF;
 868
 869         wxLogSysError(_("Thread module initialization failed: "
 870                         "can not store value in thread local storage"));
 871
 872         return FALSE;
 873     }
 874
 875     gs_critsectWaitingForGui = new wxCriticalSection();
 876
 877     gs_critsectGui = new wxCriticalSection();
 878     gs_critsectGui->Enter();
 879
 880     // no error return for GetCurrentThreadId()
 881     gs_idMainThread = ::GetCurrentThreadId();
 882
 883     return TRUE;
 884 }
 885
 886 void wxThreadModule::OnExit()
 887 {
 888     if ( !::TlsFree(gs_tlsThisThread) )
 889     {
 890         wxLogLastError("TlsFree failed.");
 891     }
 892
 893     if ( gs_critsectGui )
 894     {
 895         gs_critsectGui->Leave();
 896         delete gs_critsectGui;
 897         gs_critsectGui = NULL;
 898     }
 899
 900     delete gs_critsectWaitingForGui;
 901     gs_critsectWaitingForGui = NULL;
 902 }
 903
 904 // ----------------------------------------------------------------------------
 905 // under Windows, these functions are implemented using a critical section and
 906 // not a mutex, so the names are a bit confusing
 907 // ----------------------------------------------------------------------------
 908
 909 void WXDLLEXPORT wxMutexGuiEnter()
 910 {
 911     // this would dead lock everything...
 912     wxASSERT_MSG( !wxThread::IsMain(),
 913                   wxT("main thread doesn't want to block in wxMutexGuiEnter()!") );
 914
 915     // the order in which we enter the critical sections here is crucial!!
 916
 917     // set the flag telling to the main thread that we want to do some GUI
 918     {
 919         wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
 920
 921         gs_nWaitingForGui++;
 922     }
 923
 924     wxWakeUpMainThread();
 925
 926     // now we may block here because the main thread will soon let us in
 927     // (during the next iteration of OnIdle())
 928     gs_critsectGui->Enter();
 929 }
 930
 931 void WXDLLEXPORT wxMutexGuiLeave()
 932 {
 933     wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
 934
 935     if ( wxThread::IsMain() )
 936     {
 937         gs_bGuiOwnedByMainThread = FALSE;
 938     }
 939     else
 940     {
 941         // decrement the number of waiters now
 942         wxASSERT_MSG( gs_nWaitingForGui > 0,
 943                       wxT("calling wxMutexGuiLeave() without entering it first?") );
 944
 945         gs_nWaitingForGui--;
 946
 947         wxWakeUpMainThread();
 948     }
 949
 950     gs_critsectGui->Leave();
 951 }
 952
 953 void WXDLLEXPORT wxMutexGuiLeaveOrEnter()
 954 {
 955     wxASSERT_MSG( wxThread::IsMain(),
 956                   wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") );
 957
 958     wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
 959
 960     if ( gs_nWaitingForGui == 0 )
 961     {
 962         // no threads are waiting for GUI - so we may acquire the lock without
 963         // any danger (but only if we don't already have it)
 964         if ( !wxGuiOwnedByMainThread() )
 965         {
 966             gs_critsectGui->Enter();
 967
 968             gs_bGuiOwnedByMainThread = TRUE;
 969         }
 970         //else: already have it, nothing to do
 971     }
 972     else
 973     {
 974         // some threads are waiting, release the GUI lock if we have it
 975         if ( wxGuiOwnedByMainThread() )
 976         {
 977             wxMutexGuiLeave();
 978         }
 979         //else: some other worker thread is doing GUI
 980     }
 981 }
 982
 983 bool WXDLLEXPORT wxGuiOwnedByMainThread()
 984 {
 985     return gs_bGuiOwnedByMainThread;
 986 }
 987
 988 // wake up the main thread if it's in ::GetMessage()
 989 void WXDLLEXPORT wxWakeUpMainThread()
 990 {
 991     // sending any message would do - hopefully WM_NULL is harmless enough
 992     if ( !::PostThreadMessage(gs_idMainThread, WM_NULL, 0, 0) )
 993     {
 994         // should never happen
 995         wxLogLastError("PostThreadMessage(WM_NULL)");
 996     }
 997 }
 998
 999 bool WXDLLEXPORT wxIsWaitingForThread()
1000 {
1001     return gs_waitingForThread;
1002 }
1003
1004 #endif // wxUSE_THREADS