src/unix/threadpsx.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        threadpsx.cpp
   3 // Purpose:     wxThread (Posix) Implementation
   4 // Author:      Original from Wolfram Gloger/Guilhem Lavaux
   5 // Modified by:
   6 // Created:     04/22/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Wolfram Gloger (1996, 1997)
   9 //                  Guilhem Lavaux (1998)
  10 //                  Vadim Zeitlin (1999)
  11 //                  Robert Roebling (1999)
  12 // Licence:     wxWindows licence
  13 /////////////////////////////////////////////////////////////////////////////
  14
  15 // ============================================================================
  16 // declaration
  17 // ============================================================================
  18
  19 // ----------------------------------------------------------------------------
  20 // headers
  21 // ----------------------------------------------------------------------------
  22
  23 #ifdef __GNUG__
  24     #pragma implementation "thread.h"
  25 #endif
  26
  27 // With simple makefiles, we must ignore the file body if not using
  28 // threads.
  29 #include "wx/setup.h"
  30
  31 #if wxUSE_THREADS
  32
  33 #include "wx/thread.h"
  34 #include "wx/module.h"
  35 #include "wx/utils.h"
  36 #include "wx/log.h"
  37 #include "wx/intl.h"
  38 #include "wx/dynarray.h"
  39
  40 #include <stdio.h>
  41 #include <unistd.h>
  42 #include <pthread.h>
  43 #include <errno.h>
  44 #include <time.h>
  45
  46 #if HAVE_SCHED_H
  47     #include <sched.h>
  48 #endif
  49
  50 #ifdef __WXGTK12__
  51 #include "gtk/gtk.h"
  52 #endif
  53
  54 // ----------------------------------------------------------------------------
  55 // constants
  56 // ----------------------------------------------------------------------------
  57
  58 // the possible states of the thread and transitions from them
  59 enum wxThreadState
  60 {
  61     STATE_NEW,          // didn't start execution yet (=> RUNNING)
  62     STATE_RUNNING,      // running (=> PAUSED or EXITED)
  63     STATE_PAUSED,       // suspended (=> RUNNING or EXITED)
  64     STATE_EXITED        // thread doesn't exist any more
  65 };
  66
  67 // ----------------------------------------------------------------------------
  68 // types
  69 // ----------------------------------------------------------------------------
  70
  71 WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
  72
  73 // -----------------------------------------------------------------------------
  74 // global data
  75 // -----------------------------------------------------------------------------
  76
  77 // we keep the list of all threads created by the application to be able to
  78 // terminate them on exit if there are some left - otherwise the process would
  79 // be left in memory
  80 static wxArrayThread gs_allThreads;
  81
  82 // the id of the main thread
  83 static pthread_t gs_tidMain;
  84
  85 // the key for the pointer to the associated wxThread object
  86 static pthread_key_t gs_keySelf;
  87
  88 #ifndef __WXGTK12__
  89 // this mutex must be acquired before any call to a GUI function
  90 static wxMutex *gs_mutexGui;
  91 #endif
  92
  93 // ============================================================================
  94 // implementation
  95 // ============================================================================
  96
  97 //--------------------------------------------------------------------
  98 // wxMutex (Posix implementation)
  99 //--------------------------------------------------------------------
 100
 101 class wxMutexInternal
 102 {
 103 public:
 104     pthread_mutex_t p_mutex;
 105 };
 106
 107 wxMutex::wxMutex()
 108 {
 109     p_internal = new wxMutexInternal;
 110     pthread_mutex_init( &(p_internal->p_mutex), (const pthread_mutexattr_t*) NULL );
 111     m_locked = 0;
 112 }
 113
 114 wxMutex::~wxMutex()
 115 {
 116     if (m_locked > 0)
 117         wxLogDebug(_T("Freeing a locked mutex (%d locks)"), m_locked);
 118
 119     pthread_mutex_destroy( &(p_internal->p_mutex) );
 120     delete p_internal;
 121 }
 122
 123 wxMutexError wxMutex::Lock()
 124 {
 125     int err = pthread_mutex_lock( &(p_internal->p_mutex) );
 126     if (err == EDEADLK)
 127     {
 128         wxLogDebug(_T("Locking this mutex would lead to deadlock!"));
 129
 130         return wxMUTEX_DEAD_LOCK;
 131     }
 132
 133     m_locked++;
 134
 135     return wxMUTEX_NO_ERROR;
 136 }
 137
 138 wxMutexError wxMutex::TryLock()
 139 {
 140     if (m_locked)
 141     {
 142         return wxMUTEX_BUSY;
 143     }
 144
 145     int err = pthread_mutex_trylock( &(p_internal->p_mutex) );
 146     switch (err)
 147     {
 148         case EBUSY: return wxMUTEX_BUSY;
 149     }
 150
 151     m_locked++;
 152
 153     return wxMUTEX_NO_ERROR;
 154 }
 155
 156 wxMutexError wxMutex::Unlock()
 157 {
 158     if (m_locked > 0)
 159     {
 160         m_locked--;
 161     }
 162     else
 163     {
 164         wxLogDebug(_T("Unlocking not locked mutex."));
 165
 166         return wxMUTEX_UNLOCKED;
 167     }
 168
 169     pthread_mutex_unlock( &(p_internal->p_mutex) );
 170
 171     return wxMUTEX_NO_ERROR;
 172 }
 173
 174 //--------------------------------------------------------------------
 175 // wxCondition (Posix implementation)
 176 //--------------------------------------------------------------------
 177
 178 class wxConditionInternal
 179 {
 180 public:
 181   pthread_cond_t p_condition;
 182 };
 183
 184 wxCondition::wxCondition()
 185 {
 186     p_internal = new wxConditionInternal;
 187     pthread_cond_init( &(p_internal->p_condition), (const pthread_condattr_t *) NULL );
 188 }
 189
 190 wxCondition::~wxCondition()
 191 {
 192     pthread_cond_destroy( &(p_internal->p_condition) );
 193
 194     delete p_internal;
 195 }
 196
 197 void wxCondition::Wait(wxMutex& mutex)
 198 {
 199     pthread_cond_wait( &(p_internal->p_condition), &(mutex.p_internal->p_mutex) );
 200 }
 201
 202 bool wxCondition::Wait(wxMutex& mutex, unsigned long sec, unsigned long nsec)
 203 {
 204     struct timespec tspec;
 205
 206     tspec.tv_sec = time(0L)+sec;
 207     tspec.tv_nsec = nsec;
 208     return (pthread_cond_timedwait(&(p_internal->p_condition), &(mutex.p_internal->p_mutex), &tspec) != ETIMEDOUT);
 209 }
 210
 211 void wxCondition::Signal()
 212 {
 213     pthread_cond_signal( &(p_internal->p_condition) );
 214 }
 215
 216 void wxCondition::Broadcast()
 217 {
 218     pthread_cond_broadcast( &(p_internal->p_condition) );
 219 }
 220
 221 //--------------------------------------------------------------------
 222 // wxThread (Posix implementation)
 223 //--------------------------------------------------------------------
 224
 225 class wxThreadInternal
 226 {
 227 public:
 228     wxThreadInternal();
 229     ~wxThreadInternal();
 230
 231     // thread entry function
 232     static void *PthreadStart(void *ptr);
 233
 234 #if HAVE_THREAD_CLEANUP_FUNCTIONS
 235     // thread exit function
 236     static void PthreadCleanup(void *ptr);
 237 #endif
 238
 239     // thread actions
 240         // start the thread
 241     wxThreadError Run();
 242         // ask the thread to terminate
 243     void Wait();
 244         // wake up threads waiting for our termination
 245     void SignalExit();
 246         // go to sleep until Resume() is called
 247     void Pause();
 248         // resume the thread
 249     void Resume();
 250
 251     // accessors
 252         // priority
 253     int GetPriority() const { return m_prio; }
 254     void SetPriority(int prio) { m_prio = prio; }
 255         // state
 256     wxThreadState GetState() const { return m_state; }
 257     void SetState(wxThreadState state) { m_state = state; }
 258         // id
 259     pthread_t GetId() const { return m_threadId; }
 260     pthread_t *GetIdPtr() { return &m_threadId; }
 261         // "cancelled" flag
 262     void SetCancelFlag() { m_cancelled = TRUE; }
 263     bool WasCancelled() const { return m_cancelled; }
 264
 265 private:
 266     pthread_t     m_threadId;   // id of the thread
 267     wxThreadState m_state;      // see wxThreadState enum
 268     int           m_prio;       // in wxWindows units: from 0 to 100
 269
 270     // set when the thread should terminate
 271     bool m_cancelled;
 272
 273     // this (mutex, cond) pair is used to synchronize the main thread and this
 274     // thread in several situations:
 275     //  1. The thread function blocks until condition is signaled by Run() when
 276     //     it's initially created - this allows thread creation in "suspended"
 277     //     state
 278     //  2. The Delete() function blocks until the condition is signaled when the
 279     //     thread exits.
 280     wxMutex     m_mutex;
 281     wxCondition m_cond;
 282
 283     // another (mutex, cond) pair for Pause()/Resume() usage
 284     //
 285     // VZ: it's possible that we might reuse the mutex and condition from above
 286     //     for this too, but as I'm not at all sure that it won't create subtle
 287     //     problems with race conditions between, say, Pause() and Delete() I
 288     //     prefer this may be a bit less efficient but much safer solution
 289     wxMutex     m_mutexSuspend;
 290     wxCondition m_condSuspend;
 291 };
 292
 293 void *wxThreadInternal::PthreadStart(void *ptr)
 294 {
 295     wxThread *thread = (wxThread *)ptr;
 296     wxThreadInternal *pthread = thread->p_internal;
 297     void *status;
 298
 299     int rc = pthread_setspecific(gs_keySelf, thread);
 300     if ( rc != 0 )
 301     {
 302         wxLogSysError(rc, _("Cannot start thread: error writing TLS"));
 303
 304         return (void *)-1;
 305     }
 306 #if HAVE_THREAD_CLEANUP_FUNCTIONS
 307     // Install the cleanup handler.
 308     pthread_cleanup_push(wxThreadInternal::PthreadCleanup, ptr);
 309 #endif
 310
 311     // wait for the condition to be signaled from Run()
 312     // mutex state: currently locked by the thread which created us
 313     pthread->m_cond.Wait(pthread->m_mutex);
 314
 315     // mutex state: locked again on exit of Wait()
 316
 317     // call the main entry
 318     status = thread->Entry();
 319
 320 #if HAVE_THREAD_CLEANUP_FUNCTIONS
 321     pthread_cleanup_pop(FALSE);
 322 #endif
 323
 324     // terminate the thread
 325     thread->Exit(status);
 326
 327     wxFAIL_MSG(_T("wxThread::Exit() can't return."));
 328
 329     return NULL;
 330 }
 331
 332 #if HAVE_THREAD_CLEANUP_FUNCTIONS
 333 // Only called when the thread is explicitely killed.
 334
 335 void wxThreadInternal::PthreadCleanup(void *ptr)
 336 {
 337     wxThread *thread = (wxThread *) ptr;
 338
 339     // The thread is already considered as finished.
 340     if (thread->p_internal->GetState() == STATE_EXITED)
 341       return;
 342
 343     // first call user-level clean up code
 344     thread->OnExit();
 345
 346     // next wake up the threads waiting for us (OTOH, this function won't retur
 347     // until someone waited for us!)
 348     thread->p_internal->SetState(STATE_EXITED);
 349
 350     thread->p_internal->SignalExit();
 351 }
 352 #endif
 353
 354 wxThreadInternal::wxThreadInternal()
 355 {
 356     m_state = STATE_NEW;
 357     m_cancelled = FALSE;
 358
 359     // this mutex is locked during almost all thread lifetime - it will only be
 360     // unlocked in the very end
 361     m_mutex.Lock();
 362
 363     // this mutex is used in Pause()/Resume() and is also locked all the time
 364     // unless the thread is paused
 365     m_mutexSuspend.Lock();
 366 }
 367
 368 wxThreadInternal::~wxThreadInternal()
 369 {
 370     // GL: moved to SignalExit
 371     // m_mutexSuspend.Unlock();
 372
 373     // note that m_mutex will be unlocked by the thread which waits for our
 374     // termination
 375 }
 376
 377 wxThreadError wxThreadInternal::Run()
 378 {
 379     wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
 380                  _T("thread may only be started once after successful Create()") );
 381
 382     // the mutex was locked on Create(), so we will be able to lock it again
 383     // only when the thread really starts executing and enters the wait -
 384     // otherwise we might signal the condition before anybody is waiting for it
 385     wxMutexLocker lock(m_mutex);
 386     m_cond.Signal();
 387
 388     m_state = STATE_RUNNING;
 389
 390     return wxTHREAD_NO_ERROR;
 391
 392     // now the mutex is unlocked back - but just to allow Wait() function to
 393     // terminate by relocking it, so the net result is that the worker thread
 394     // starts executing and the mutex is still locked
 395 }
 396
 397 void wxThreadInternal::Wait()
 398 {
 399     wxCHECK_RET( WasCancelled(), _T("thread should have been cancelled first") );
 400
 401     // if the thread we're waiting for is waiting for the GUI mutex, we will
 402     // deadlock so make sure we release it temporarily
 403     if ( wxThread::IsMain() )
 404         wxMutexGuiLeave();
 405
 406     printf("Entering wait ...\n");
 407     // entering Wait() releases the mutex thus allowing SignalExit() to acquire
 408     // it and to signal us its termination
 409     m_cond.Wait(m_mutex);
 410     printf("Exiting wait ...\n");
 411
 412     // mutex is still in the locked state - relocked on exit from Wait(), so
 413     // unlock it - we don't need it any more, the thread has already terminated
 414     m_mutex.Unlock();
 415
 416     // reacquire GUI mutex
 417     if ( wxThread::IsMain() )
 418         wxMutexGuiEnter();
 419 }
 420
 421 void wxThreadInternal::SignalExit()
 422 {
 423     printf("SignalExit\n");
 424     // GL: Unlock mutexSuspend here.
 425     m_mutexSuspend.Unlock();
 426
 427     // as mutex is currently locked, this will block until some other thread
 428     // (normally the same which created this one) unlocks it by entering Wait()
 429     m_mutex.Lock();
 430     printf("Mutex acquired\n");
 431
 432     // wake up all the threads waiting for our termination
 433     m_cond.Broadcast();
 434
 435     // after this call mutex will be finally unlocked
 436     m_mutex.Unlock();
 437     printf("Mutex unacquired\n");
 438 }
 439
 440 void wxThreadInternal::Pause()
 441 {
 442     // the state is set from the thread which pauses us first, this function
 443     // is called later so the state should have been already set
 444     wxCHECK_RET( m_state == STATE_PAUSED,
 445                  _T("thread must first be paused with wxThread::Pause().") );
 446
 447     // don't pause the thread which is being terminated - this would lead to
 448     // deadlock if the thread is paused after Delete() had called Resume() but
 449     // before it had time to call Wait()
 450     if ( WasCancelled() )
 451         return;
 452
 453     // wait until the condition is signaled from Resume()
 454     m_condSuspend.Wait(m_mutexSuspend);
 455 }
 456
 457 void wxThreadInternal::Resume()
 458 {
 459     wxCHECK_RET( m_state == STATE_PAUSED,
 460                  _T("can't resume thread which is not suspended.") );
 461
 462     // we will be able to lock this mutex only when Pause() starts waiting
 463     wxMutexLocker lock(m_mutexSuspend);
 464     m_condSuspend.Signal();
 465
 466     SetState(STATE_RUNNING);
 467 }
 468
 469 // -----------------------------------------------------------------------------
 470 // static functions
 471 // -----------------------------------------------------------------------------
 472
 473 wxThread *wxThread::This()
 474 {
 475     return (wxThread *)pthread_getspecific(gs_keySelf);
 476 }
 477
 478 bool wxThread::IsMain()
 479 {
 480     return (bool)pthread_equal(pthread_self(), gs_tidMain);
 481 }
 482
 483 void wxThread::Yield()
 484 {
 485     sched_yield();
 486 }
 487
 488 void wxThread::Sleep(unsigned long milliseconds)
 489 {
 490     wxUsleep(milliseconds);
 491 }
 492
 493 // -----------------------------------------------------------------------------
 494 // creating thread
 495 // -----------------------------------------------------------------------------
 496
 497 wxThread::wxThread()
 498 {
 499     // add this thread to the global list of all threads
 500     gs_allThreads.Add(this);
 501
 502     p_internal = new wxThreadInternal();
 503 }
 504
 505 wxThreadError wxThread::Create()
 506 {
 507     if (p_internal->GetState() != STATE_NEW)
 508         return wxTHREAD_RUNNING;
 509
 510     // set up the thread attribute: right now, we only set thread priority
 511     pthread_attr_t attr;
 512     pthread_attr_init(&attr);
 513
 514 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
 515     int prio;
 516     if ( pthread_attr_getschedpolicy(&attr, &prio) != 0 )
 517     {
 518         wxLogError(_("Cannot retrieve thread scheduling policy."));
 519     }
 520
 521     int min_prio = sched_get_priority_min(prio),
 522         max_prio = sched_get_priority_max(prio);
 523
 524     if ( min_prio == -1 || max_prio == -1 )
 525     {
 526         wxLogError(_("Cannot get priority range for scheduling policy %d."),
 527                    prio);
 528     }
 529     else
 530     {
 531         struct sched_param sp;
 532         pthread_attr_getschedparam(&attr, &sp);
 533         sp.sched_priority = min_prio +
 534                            (p_internal->GetPriority()*(max_prio-min_prio))/100;
 535         pthread_attr_setschedparam(&attr, &sp);
 536     }
 537 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS
 538
 539 #ifdef HAVE_PTHREAD_ATTR_SETSCOPE
 540     // this will make the threads created by this process really concurrent
 541     pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
 542 #endif // HAVE_PTHREAD_ATTR_SETSCOPE
 543
 544     // create the new OS thread object
 545     int rc = pthread_create(p_internal->GetIdPtr(), &attr,
 546                             wxThreadInternal::PthreadStart, (void *)this);
 547     pthread_attr_destroy(&attr);
 548
 549     if ( rc != 0 )
 550     {
 551         p_internal->SetState(STATE_EXITED);
 552         return wxTHREAD_NO_RESOURCE;
 553     }
 554
 555     return wxTHREAD_NO_ERROR;
 556 }
 557
 558 wxThreadError wxThread::Run()
 559 {
 560     return p_internal->Run();
 561 }
 562
 563 // -----------------------------------------------------------------------------
 564 // misc accessors
 565 // -----------------------------------------------------------------------------
 566
 567 void wxThread::SetPriority(unsigned int prio)
 568 {
 569     wxCHECK_RET( ((int)WXTHREAD_MIN_PRIORITY <= (int)prio) &&
 570                  ((int)prio <= (int)WXTHREAD_MAX_PRIORITY),
 571                  _T("invalid thread priority") );
 572
 573     wxCriticalSectionLocker lock(m_critsect);
 574
 575     switch ( p_internal->GetState() )
 576     {
 577         case STATE_NEW:
 578             // thread not yet started, priority will be set when it is
 579             p_internal->SetPriority(prio);
 580             break;
 581
 582         case STATE_RUNNING:
 583         case STATE_PAUSED:
 584 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
 585             {
 586                 struct sched_param sparam;
 587                 sparam.sched_priority = prio;
 588
 589                 if ( pthread_setschedparam(p_internal->GetId(),
 590                                            SCHED_OTHER, &sparam) != 0 )
 591                 {
 592                     wxLogError(_("Failed to set thread priority %d."), prio);
 593                 }
 594             }
 595 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS
 596             break;
 597
 598         case STATE_EXITED:
 599         default:
 600             wxFAIL_MSG(_T("impossible to set thread priority in this state"));
 601     }
 602 }
 603
 604 unsigned int wxThread::GetPriority() const
 605 {
 606     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
 607
 608     return p_internal->GetPriority();
 609 }
 610
 611 unsigned long wxThread::GetID() const
 612 {
 613     return (unsigned long)p_internal->GetId();
 614 }
 615
 616 // -----------------------------------------------------------------------------
 617 // pause/resume
 618 // -----------------------------------------------------------------------------
 619
 620 wxThreadError wxThread::Pause()
 621 {
 622     wxCriticalSectionLocker lock(m_critsect);
 623
 624     if ( p_internal->GetState() != STATE_RUNNING )
 625     {
 626         wxLogDebug(_T("Can't pause thread which is not running."));
 627
 628         return wxTHREAD_NOT_RUNNING;
 629     }
 630
 631     p_internal->SetState(STATE_PAUSED);
 632
 633     return wxTHREAD_NO_ERROR;
 634 }
 635
 636 wxThreadError wxThread::Resume()
 637 {
 638     wxCriticalSectionLocker lock(m_critsect);
 639
 640     if ( p_internal->GetState() == STATE_PAUSED )
 641     {
 642         m_critsect.Leave();
 643         p_internal->Resume();
 644         m_critsect.Enter();
 645
 646         return wxTHREAD_NO_ERROR;
 647     }
 648     else
 649     {
 650         wxLogDebug(_T("Attempt to resume a thread which is not paused."));
 651
 652         return wxTHREAD_MISC_ERROR;
 653     }
 654 }
 655
 656 // -----------------------------------------------------------------------------
 657 // exiting thread
 658 // -----------------------------------------------------------------------------
 659
 660 wxThread::ExitCode wxThread::Delete()
 661 {
 662     m_critsect.Enter();
 663     wxThreadState state = p_internal->GetState();
 664     m_critsect.Leave();
 665
 666     // ask the thread to stop
 667     p_internal->SetCancelFlag();
 668
 669     switch ( state )
 670     {
 671         case STATE_NEW:
 672         case STATE_EXITED:
 673             // nothing to do
 674             break;
 675
 676         case STATE_PAUSED:
 677             // resume the thread first
 678             Resume();
 679
 680             // fall through
 681
 682         default:
 683             // wait until the thread stops
 684             p_internal->Wait();
 685     }
 686
 687     return NULL;
 688 }
 689
 690 wxThreadError wxThread::Kill()
 691 {
 692     switch ( p_internal->GetState() )
 693     {
 694         case STATE_NEW:
 695         case STATE_EXITED:
 696             return wxTHREAD_NOT_RUNNING;
 697
 698         default:
 699 #ifdef HAVE_PTHREAD_CANCEL
 700             if ( pthread_cancel(p_internal->GetId()) != 0 )
 701 #endif
 702             {
 703                 wxLogError(_("Failed to terminate a thread."));
 704
 705                 return wxTHREAD_MISC_ERROR;
 706             }
 707
 708             return wxTHREAD_NO_ERROR;
 709     }
 710 }
 711
 712 void wxThread::Exit(void *status)
 713 {
 714     // first call user-level clean up code
 715     OnExit();
 716     printf(" ... OnExit()\n");
 717
 718     // next wake up the threads waiting for us (OTOH, this function won't return
 719     // until someone waited for us!)
 720     p_internal->SignalExit();
 721     printf(" ... SignalExit()\n");
 722
 723     p_internal->SetState(STATE_EXITED);
 724     printf(" ... SetState()\n");
 725
 726     // delete both C++ thread object and terminate the OS thread object
 727     // GL: This is very ugly and buggy ...
 728 //    delete this;
 729     printf(" ... Exit\n");
 730     pthread_exit(status);
 731 }
 732
 733 // also test whether we were paused
 734 bool wxThread::TestDestroy()
 735 {
 736     wxCriticalSectionLocker lock(m_critsect);
 737
 738     if ( p_internal->GetState() == STATE_PAUSED )
 739     {
 740         // leave the crit section or the other threads will stop too if they try
 741         // to call any of (seemingly harmless) IsXXX() functions while we sleep
 742         m_critsect.Leave();
 743
 744         p_internal->Pause();
 745
 746         // enter it back before it's finally left in lock object dtor
 747         m_critsect.Enter();
 748     }
 749
 750     return p_internal->WasCancelled();
 751 }
 752
 753 wxThread::~wxThread()
 754 {
 755     // remove this thread from the global array
 756     gs_allThreads.Remove(this);
 757 }
 758
 759 // -----------------------------------------------------------------------------
 760 // state tests
 761 // -----------------------------------------------------------------------------
 762
 763 bool wxThread::IsRunning() const
 764 {
 765     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
 766
 767     return p_internal->GetState() == STATE_RUNNING;
 768 }
 769
 770 bool wxThread::IsAlive() const
 771 {
 772     wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
 773
 774     switch ( p_internal->GetState() )
 775     {
 776         case STATE_RUNNING:
 777         case STATE_PAUSED:
 778             return TRUE;
 779
 780         default:
 781             return FALSE;
 782     }
 783 }
 784
 785 bool wxThread::IsPaused() const
 786 {
 787     wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
 788
 789     return (p_internal->GetState() == STATE_PAUSED);
 790 }
 791
 792 //--------------------------------------------------------------------
 793 // wxThreadModule
 794 //--------------------------------------------------------------------
 795
 796 class wxThreadModule : public wxModule
 797 {
 798 public:
 799     virtual bool OnInit();
 800     virtual void OnExit();
 801
 802 private:
 803     DECLARE_DYNAMIC_CLASS(wxThreadModule)
 804 };
 805
 806 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
 807
 808 bool wxThreadModule::OnInit()
 809 {
 810     int rc = pthread_key_create(&gs_keySelf, NULL /* dtor function */);
 811     if ( rc != 0 )
 812     {
 813         wxLogSysError(rc, _("Thread module initialization failed: "
 814                             "failed to create thread key"));
 815
 816         return FALSE;
 817     }
 818
 819 #ifndef __WXGTK12__
 820     gs_mutexGui = new wxMutex();
 821 #endif
 822
 823     gs_tidMain = pthread_self();
 824
 825 #ifndef __WXGTK12__
 826     gs_mutexGui->Lock();
 827 #endif
 828
 829     return TRUE;
 830 }
 831
 832 void wxThreadModule::OnExit()
 833 {
 834     wxASSERT_MSG( wxThread::IsMain(), _T("only main thread can be here") );
 835
 836     // terminate any threads left
 837     size_t count = gs_allThreads.GetCount();
 838     if ( count != 0u )
 839         wxLogDebug(_T("Some threads were not terminated by the application."));
 840
 841     for ( size_t n = 0u; n < count; n++ )
 842     {
 843         gs_allThreads[n]->Delete();
 844     }
 845
 846 #ifndef __WXGTK12__
 847     // destroy GUI mutex
 848     gs_mutexGui->Unlock();
 849
 850     delete gs_mutexGui;
 851 #endif
 852
 853     // and free TLD slot
 854     (void)pthread_key_delete(gs_keySelf);
 855 }
 856
 857 // ----------------------------------------------------------------------------
 858 // global functions
 859 // ----------------------------------------------------------------------------
 860
 861 void wxMutexGuiEnter()
 862 {
 863 #ifdef __WXGTK12__
 864   gdk_threads_enter();
 865 #else
 866   gs_mutexGui->Lock();
 867 #endif
 868 }
 869
 870 void wxMutexGuiLeave()
 871 {
 872 #ifdef __WXGTK12__
 873   gdk_threads_leave();
 874 #else
 875   gs_mutexGui->Unlock();
 876 #endif
 877 }
 878
 879 #endif
 880   // wxUSE_THREADS