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 int wxThread::GetCPUCount()
 531 {
 532     return -1;
 533 }
 534
 535 bool wxThread::SetConcurrency(size_t level)
 536 {
 537     // ok only for the default one
 538     return level == 0;
 539 }
 540
 541 // ctor and dtor
 542 // -------------
 543
 544 wxThread::wxThread(wxThreadKind kind)
 545 {
 546     m_internal = new wxThreadInternal();
 547
 548     m_isDetached = kind == wxTHREAD_DETACHED;
 549 }
 550
 551 wxThread::~wxThread()
 552 {
 553     delete m_internal;
 554 }
 555
 556 // create/start thread
 557 // -------------------
 558
 559 wxThreadError wxThread::Create()
 560 {
 561     wxCriticalSectionLocker lock(m_critsect);
 562
 563     if ( !m_internal->Create(this) )
 564         return wxTHREAD_NO_RESOURCE;
 565
 566     return wxTHREAD_NO_ERROR;
 567 }
 568
 569 wxThreadError wxThread::Run()
 570 {
 571     wxCriticalSectionLocker lock(m_critsect);
 572
 573     if ( m_internal->GetState() != STATE_NEW )
 574     {
 575         // actually, it may be almost any state at all, not only STATE_RUNNING
 576         return wxTHREAD_RUNNING;
 577     }
 578
 579     // the thread has just been created and is still suspended - let it run
 580     return Resume();
 581 }
 582
 583 // suspend/resume thread
 584 // ---------------------
 585
 586 wxThreadError wxThread::Pause()
 587 {
 588     wxCriticalSectionLocker lock(m_critsect);
 589
 590     return m_internal->Suspend() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
 591 }
 592
 593 wxThreadError wxThread::Resume()
 594 {
 595     wxCriticalSectionLocker lock(m_critsect);
 596
 597     return m_internal->Resume() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
 598 }
 599
 600 // stopping thread
 601 // ---------------
 602
 603 wxThread::ExitCode wxThread::Wait()
 604 {
 605     // although under Windows we can wait for any thread, it's an error to
 606     // wait for a detached one in wxWin API
 607     wxCHECK_MSG( !IsDetached(), (ExitCode)-1,
 608                  _T("can't wait for detached thread") );
 609
 610     ExitCode rc = (ExitCode)-1;
 611
 612     (void)Delete(&rc);
 613
 614     m_internal->Free();
 615
 616     return rc;
 617 }
 618
 619 wxThreadError wxThread::Delete(ExitCode *pRc)
 620 {
 621     ExitCode rc = 0;
 622
 623     // Delete() is always safe to call, so consider all possible states
 624     if ( IsPaused() )
 625         Resume();
 626
 627     HANDLE hThread = m_internal->GetHandle();
 628
 629     if ( IsRunning() )
 630     {
 631         if ( IsMain() )
 632         {
 633             // set flag for wxIsWaitingForThread()
 634             gs_waitingForThread = TRUE;
 635
 636 #if wxUSE_GUI
 637             wxBeginBusyCursor();
 638 #endif // wxUSE_GUI
 639         }
 640
 641         // ask the thread to terminate
 642         {
 643             wxCriticalSectionLocker lock(m_critsect);
 644
 645             m_internal->Cancel();
 646         }
 647
 648 #if wxUSE_GUI
 649         // we can't just wait for the thread to terminate because it might be
 650         // calling some GUI functions and so it will never terminate before we
 651         // process the Windows messages that result from these functions
 652         DWORD result;
 653         do
 654         {
 655             result = ::MsgWaitForMultipleObjects
 656                      (
 657                        1,              // number of objects to wait for
 658                        &hThread,       // the objects
 659                        FALSE,          // don't wait for all objects
 660                        INFINITE,       // no timeout
 661                        QS_ALLEVENTS    // return as soon as there are any events
 662                      );
 663
 664             switch ( result )
 665             {
 666                 case 0xFFFFFFFF:
 667                     // error
 668                     wxLogSysError(_("Can not wait for thread termination"));
 669                     Kill();
 670                     return wxTHREAD_KILLED;
 671
 672                 case WAIT_OBJECT_0:
 673                     // thread we're waiting for terminated
 674                     break;
 675
 676                 case WAIT_OBJECT_0 + 1:
 677                     // new message arrived, process it
 678                     if ( !wxTheApp->DoMessage() )
 679                     {
 680                         // WM_QUIT received: kill the thread
 681                         Kill();
 682
 683                         return wxTHREAD_KILLED;
 684                     }
 685
 686                     if ( IsMain() )
 687                     {
 688                         // give the thread we're waiting for chance to exit
 689                         // from the GUI call it might have been in
 690                         if ( (gs_nWaitingForGui > 0) && wxGuiOwnedByMainThread() )
 691                         {
 692                             wxMutexGuiLeave();
 693                         }
 694                     }
 695
 696                     break;
 697
 698                 default:
 699                     wxFAIL_MSG(wxT("unexpected result of MsgWaitForMultipleObject"));
 700             }
 701         } while ( result != WAIT_OBJECT_0 );
 702 #else // !wxUSE_GUI
 703         // simply wait for the thread to terminate
 704         //
 705         // OTOH, even console apps create windows (in wxExecute, for WinSock
 706         // &c), so may be use MsgWaitForMultipleObject() too here?
 707         if ( WaitForSingleObject(hThread, INFINITE) != WAIT_OBJECT_0 )
 708         {
 709             wxFAIL_MSG(wxT("unexpected result of WaitForSingleObject"));
 710         }
 711 #endif // wxUSE_GUI/!wxUSE_GUI
 712
 713         if ( IsMain() )
 714         {
 715             gs_waitingForThread = FALSE;
 716
 717 #if wxUSE_GUI
 718             wxEndBusyCursor();
 719 #endif // wxUSE_GUI
 720         }
 721     }
 722
 723     if ( !::GetExitCodeThread(hThread, (LPDWORD)&rc) )
 724     {
 725         wxLogLastError("GetExitCodeThread");
 726
 727         rc = (ExitCode)-1;
 728     }
 729
 730     if ( IsDetached() )
 731     {
 732         // if the thread exits normally, this is done in WinThreadStart, but in
 733         // this case it would have been too early because
 734         // MsgWaitForMultipleObject() would fail if the therad handle was
 735         // closed while we were waiting on it, so we must do it here
 736         delete this;
 737     }
 738
 739     wxASSERT_MSG( (DWORD)rc != STILL_ACTIVE,
 740                   wxT("thread must be already terminated.") );
 741
 742     if ( pRc )
 743         *pRc = rc;
 744
 745     return rc == (ExitCode)-1 ? wxTHREAD_MISC_ERROR : wxTHREAD_NO_ERROR;
 746 }
 747
 748 wxThreadError wxThread::Kill()
 749 {
 750     if ( !IsRunning() )
 751         return wxTHREAD_NOT_RUNNING;
 752
 753     if ( !::TerminateThread(m_internal->GetHandle(), (DWORD)-1) )
 754     {
 755         wxLogSysError(_("Couldn't terminate thread"));
 756
 757         return wxTHREAD_MISC_ERROR;
 758     }
 759
 760     m_internal->Free();
 761
 762     if ( IsDetached() )
 763     {
 764         delete this;
 765     }
 766
 767     return wxTHREAD_NO_ERROR;
 768 }
 769
 770 void wxThread::Exit(ExitCode status)
 771 {
 772     m_internal->Free();
 773
 774     if ( IsDetached() )
 775     {
 776         delete this;
 777     }
 778
 779 #ifdef __VISUALC__
 780     _endthreadex((unsigned)status);
 781 #else // !VC++
 782     ::ExitThread((DWORD)status);
 783 #endif // VC++/!VC++
 784
 785     wxFAIL_MSG(wxT("Couldn't return from ExitThread()!"));
 786 }
 787
 788 // priority setting
 789 // ----------------
 790
 791 void wxThread::SetPriority(unsigned int prio)
 792 {
 793     wxCriticalSectionLocker lock(m_critsect);
 794
 795     m_internal->SetPriority(prio);
 796 }
 797
 798 unsigned int wxThread::GetPriority() const
 799 {
 800     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
 801
 802     return m_internal->GetPriority();
 803 }
 804
 805 unsigned long wxThread::GetId() const
 806 {
 807     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
 808
 809     return (unsigned long)m_internal->GetId();
 810 }
 811
 812 bool wxThread::IsRunning() const
 813 {
 814     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
 815
 816     return m_internal->GetState() == STATE_RUNNING;
 817 }
 818
 819 bool wxThread::IsAlive() const
 820 {
 821     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
 822
 823     return (m_internal->GetState() == STATE_RUNNING) ||
 824            (m_internal->GetState() == STATE_PAUSED);
 825 }
 826
 827 bool wxThread::IsPaused() const
 828 {
 829     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
 830
 831     return m_internal->GetState() == STATE_PAUSED;
 832 }
 833
 834 bool wxThread::TestDestroy()
 835 {
 836     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
 837
 838     return m_internal->GetState() == STATE_CANCELED;
 839 }
 840
 841 // ----------------------------------------------------------------------------
 842 // Automatic initialization for thread module
 843 // ----------------------------------------------------------------------------
 844
 845 class wxThreadModule : public wxModule
 846 {
 847 public:
 848     virtual bool OnInit();
 849     virtual void OnExit();
 850
 851 private:
 852     DECLARE_DYNAMIC_CLASS(wxThreadModule)
 853 };
 854
 855 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
 856
 857 bool wxThreadModule::OnInit()
 858 {
 859     // allocate TLS index for storing the pointer to the current thread
 860     gs_tlsThisThread = ::TlsAlloc();
 861     if ( gs_tlsThisThread == 0xFFFFFFFF )
 862     {
 863         // in normal circumstances it will only happen if all other
 864         // TLS_MINIMUM_AVAILABLE (>= 64) indices are already taken - in other
 865         // words, this should never happen
 866         wxLogSysError(_("Thread module initialization failed: "
 867                         "impossible to allocate index in thread "
 868                         "local storage"));
 869
 870         return FALSE;
 871     }
 872
 873     // main thread doesn't have associated wxThread object, so store 0 in the
 874     // TLS instead
 875     if ( !::TlsSetValue(gs_tlsThisThread, (LPVOID)0) )
 876     {
 877         ::TlsFree(gs_tlsThisThread);
 878         gs_tlsThisThread = 0xFFFFFFFF;
 879
 880         wxLogSysError(_("Thread module initialization failed: "
 881                         "can not store value in thread local storage"));
 882
 883         return FALSE;
 884     }
 885
 886     gs_critsectWaitingForGui = new wxCriticalSection();
 887
 888     gs_critsectGui = new wxCriticalSection();
 889     gs_critsectGui->Enter();
 890
 891     // no error return for GetCurrentThreadId()
 892     gs_idMainThread = ::GetCurrentThreadId();
 893
 894     return TRUE;
 895 }
 896
 897 void wxThreadModule::OnExit()
 898 {
 899     if ( !::TlsFree(gs_tlsThisThread) )
 900     {
 901         wxLogLastError("TlsFree failed.");
 902     }
 903
 904     if ( gs_critsectGui )
 905     {
 906         gs_critsectGui->Leave();
 907         delete gs_critsectGui;
 908         gs_critsectGui = NULL;
 909     }
 910
 911     delete gs_critsectWaitingForGui;
 912     gs_critsectWaitingForGui = NULL;
 913 }
 914
 915 // ----------------------------------------------------------------------------
 916 // under Windows, these functions are implemented using a critical section and
 917 // not a mutex, so the names are a bit confusing
 918 // ----------------------------------------------------------------------------
 919
 920 void WXDLLEXPORT wxMutexGuiEnter()
 921 {
 922     // this would dead lock everything...
 923     wxASSERT_MSG( !wxThread::IsMain(),
 924                   wxT("main thread doesn't want to block in wxMutexGuiEnter()!") );
 925
 926     // the order in which we enter the critical sections here is crucial!!
 927
 928     // set the flag telling to the main thread that we want to do some GUI
 929     {
 930         wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
 931
 932         gs_nWaitingForGui++;
 933     }
 934
 935     wxWakeUpMainThread();
 936
 937     // now we may block here because the main thread will soon let us in
 938     // (during the next iteration of OnIdle())
 939     gs_critsectGui->Enter();
 940 }
 941
 942 void WXDLLEXPORT wxMutexGuiLeave()
 943 {
 944     wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
 945
 946     if ( wxThread::IsMain() )
 947     {
 948         gs_bGuiOwnedByMainThread = FALSE;
 949     }
 950     else
 951     {
 952         // decrement the number of waiters now
 953         wxASSERT_MSG( gs_nWaitingForGui > 0,
 954                       wxT("calling wxMutexGuiLeave() without entering it first?") );
 955
 956         gs_nWaitingForGui--;
 957
 958         wxWakeUpMainThread();
 959     }
 960
 961     gs_critsectGui->Leave();
 962 }
 963
 964 void WXDLLEXPORT wxMutexGuiLeaveOrEnter()
 965 {
 966     wxASSERT_MSG( wxThread::IsMain(),
 967                   wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") );
 968
 969     wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
 970
 971     if ( gs_nWaitingForGui == 0 )
 972     {
 973         // no threads are waiting for GUI - so we may acquire the lock without
 974         // any danger (but only if we don't already have it)
 975         if ( !wxGuiOwnedByMainThread() )
 976         {
 977             gs_critsectGui->Enter();
 978
 979             gs_bGuiOwnedByMainThread = TRUE;
 980         }
 981         //else: already have it, nothing to do
 982     }
 983     else
 984     {
 985         // some threads are waiting, release the GUI lock if we have it
 986         if ( wxGuiOwnedByMainThread() )
 987         {
 988             wxMutexGuiLeave();
 989         }
 990         //else: some other worker thread is doing GUI
 991     }
 992 }
 993
 994 bool WXDLLEXPORT wxGuiOwnedByMainThread()
 995 {
 996     return gs_bGuiOwnedByMainThread;
 997 }
 998
 999 // wake up the main thread if it's in ::GetMessage()
1000 void WXDLLEXPORT wxWakeUpMainThread()
1001 {
1002     // sending any message would do - hopefully WM_NULL is harmless enough
1003     if ( !::PostThreadMessage(gs_idMainThread, WM_NULL, 0, 0) )
1004     {
1005         // should never happen
1006         wxLogLastError("PostThreadMessage(WM_NULL)");
1007     }
1008 }
1009
1010 bool WXDLLEXPORT wxIsWaitingForThread()
1011 {
1012     return gs_waitingForThread;
1013 }
1014
1015 #endif // wxUSE_THREADS