src/msw/thread.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        thread.cpp
   3 // Purpose:     wxThread 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); Guilhem Lavaux (1998)
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "thread.h"
  14 #endif
  15
  16 // this is here to regen the precompiled header in the ide compile otherwise the
  17 // compiler crashes in vc5 (nfi why)
  18 // For compilers that support precompilation, includes "wx.h".
  19 #include "wx/wxprec.h"
  20
  21 #if defined(__BORLANDC__)
  22 #pragma hdrstop
  23 #endif
  24
  25 #ifndef WX_PRECOMP
  26 #include "wx/wx.h"
  27 #endif
  28
  29 #include <stdio.h>
  30
  31 #include <windows.h>
  32 #include "wx/module.h"
  33 #include "wx/thread.h"
  34
  35 enum thread_state {
  36   STATE_IDLE = 0,
  37   STATE_RUNNING,
  38   STATE_CANCELED,
  39   STATE_EXITED
  40 };
  41
  42 /////////////////////////////////////////////////////////////////////////////
  43 // Static variables
  44 /////////////////////////////////////////////////////////////////////////////
  45
  46 static HANDLE p_mainid;
  47 wxMutex *wxMainMutex; // controls access to all GUI functions
  48
  49 /////////////////////////////////////////////////////////////////////////////
  50 // Windows implementation
  51 /////////////////////////////////////////////////////////////////////////////
  52
  53 class wxMutexInternal {
  54 public:
  55   HANDLE p_mutex;
  56 };
  57
  58 wxMutex::wxMutex()
  59 {
  60   p_internal = new wxMutexInternal;
  61   p_internal->p_mutex = CreateMutex(NULL, FALSE, NULL);
  62   m_locked = 0;
  63 }
  64
  65 wxMutex::~wxMutex()
  66 {
  67   if (m_locked > 0)
  68     wxDebugMsg("wxMutex warning: freeing a locked mutex (%d locks)\n", m_locked);
  69   CloseHandle(p_internal->p_mutex);
  70 }
  71
  72 wxMutexError wxMutex::Lock()
  73 {
  74   DWORD ret;
  75
  76   ret = WaitForSingleObject(p_internal->p_mutex, INFINITE);
  77   if (ret == WAIT_ABANDONED)
  78     return MUTEX_BUSY;
  79
  80   m_locked++;
  81   return MUTEX_NO_ERROR;
  82 }
  83
  84 wxMutexError wxMutex::TryLock()
  85 {
  86   DWORD ret;
  87
  88   ret = WaitForSingleObject(p_internal->p_mutex, 0);
  89   if (ret == WAIT_TIMEOUT || ret == WAIT_ABANDONED)
  90     return MUTEX_BUSY;
  91
  92   m_locked++;
  93   return MUTEX_NO_ERROR;
  94 }
  95
  96 wxMutexError wxMutex::Unlock()
  97 {
  98   BOOL ret;
  99
 100   if (m_locked > 0)
 101     m_locked--;
 102
 103     // Why does this have 3 args? The redundant ones removed by JACS
 104 //  ret = ReleaseMutex(p_internal->p_mutex, 1, NULL);
 105   ret = ReleaseMutex(p_internal->p_mutex);
 106   return MUTEX_NO_ERROR;
 107 }
 108
 109 class wxConditionInternal {
 110 public:
 111   HANDLE event;
 112   int waiters;
 113 };
 114
 115 wxCondition::wxCondition()
 116 {
 117   p_internal = new wxConditionInternal;
 118   p_internal->event = CreateEvent(NULL, FALSE, FALSE, NULL);
 119   p_internal->waiters = 0;
 120 }
 121
 122 wxCondition::~wxCondition()
 123 {
 124   CloseHandle(p_internal->event);
 125 }
 126
 127 void wxCondition::Wait(wxMutex& mutex)
 128 {
 129   mutex.Unlock();
 130   p_internal->waiters++;
 131   WaitForSingleObject(p_internal->event, INFINITE);
 132   p_internal->waiters--;
 133   mutex.Lock();
 134 }
 135
 136 bool wxCondition::Wait(wxMutex& mutex, unsigned long sec,
 137                        unsigned long nsec)
 138 {
 139   DWORD ret;
 140
 141   mutex.Unlock();
 142   p_internal->waiters++;
 143   ret = WaitForSingleObject(p_internal->event, (sec*1000)+(nsec/1000000));
 144   p_internal->waiters--;
 145   mutex.Lock();
 146
 147   return (ret != WAIT_TIMEOUT);
 148 }
 149
 150 void wxCondition::Signal()
 151 {
 152   SetEvent(p_internal->event);
 153 }
 154
 155 void wxCondition::Broadcast()
 156 {
 157   int i;
 158
 159   for (i=0;i<p_internal->waiters;i++)
 160     SetEvent(p_internal->event);
 161 }
 162
 163 class wxThreadInternal {
 164 public:
 165   static DWORD WinThreadStart(LPVOID arg);
 166
 167   HANDLE thread_id;
 168   int state;
 169   int prio, defer;
 170   DWORD tid;
 171 };
 172
 173 DWORD wxThreadInternal::WinThreadStart(LPVOID arg)
 174 {
 175   wxThread *ptr = (wxThread *)arg;
 176   DWORD ret;
 177
 178   ret = (DWORD)ptr->Entry();
 179   ptr->p_internal->state = STATE_EXITED;
 180
 181   return ret;
 182 }
 183
 184 wxThreadError wxThread::Create()
 185 {
 186   int win_prio, prio = p_internal->prio;
 187
 188   p_internal->thread_id = CreateThread(NULL, 0,
 189                    (LPTHREAD_START_ROUTINE)wxThreadInternal::WinThreadStart,
 190                    (void *)this, CREATE_SUSPENDED, &p_internal->tid);
 191   if (p_internal->thread_id == NULL) {
 192     printf("Error = %d\n", GetLastError());
 193     return THREAD_NO_RESOURCE;
 194   }
 195
 196   if (prio <= 20)
 197     win_prio = THREAD_PRIORITY_LOWEST;
 198   else if (prio <= 40)
 199     win_prio = THREAD_PRIORITY_BELOW_NORMAL;
 200   else if (prio <= 60)
 201     win_prio = THREAD_PRIORITY_NORMAL;
 202   else if (prio <= 80)
 203     win_prio = THREAD_PRIORITY_ABOVE_NORMAL;
 204   else if (prio <= 100)
 205     win_prio = THREAD_PRIORITY_HIGHEST;
 206
 207   SetThreadPriority(p_internal->thread_id, win_prio);
 208
 209   ResumeThread(p_internal->thread_id);
 210   p_internal->state = STATE_RUNNING;
 211
 212   return THREAD_NO_ERROR;
 213 }
 214
 215 wxThreadError wxThread::Destroy()
 216 {
 217   if (p_internal->state != STATE_RUNNING)
 218     return THREAD_NOT_RUNNING;
 219
 220   if (p_internal->defer == FALSE)
 221     TerminateThread(p_internal->thread_id, 0);
 222   else
 223     p_internal->state = STATE_CANCELED;
 224
 225   return THREAD_NO_ERROR;
 226 }
 227
 228 void wxThread::Exit(void *status)
 229 {
 230   p_internal->state = STATE_EXITED;
 231   ExitThread((DWORD)status);
 232 }
 233
 234 void wxThread::SetPriority(int prio)
 235 {
 236   p_internal->prio = prio;
 237 }
 238
 239 int wxThread::GetPriority() const
 240 {
 241   return p_internal->prio;
 242 }
 243
 244 void wxThread::DeferDestroy(bool on)
 245 {
 246   p_internal->defer = on;
 247 }
 248
 249 void wxThread::TestDestroy()
 250 {
 251   if (p_internal->state == STATE_CANCELED)
 252     ExitThread(0);
 253 }
 254
 255 void *wxThread::Join()
 256 {
 257   DWORD exit_code;
 258
 259   if (p_internal->state == STATE_IDLE)
 260     return NULL;
 261
 262   if (wxThread::IsMain())
 263     wxMainMutex->Unlock();
 264   WaitForSingleObject(p_internal->thread_id, INFINITE);
 265   if (wxThread::IsMain())
 266     wxMainMutex->Lock();
 267
 268   GetExitCodeThread(p_internal->thread_id, &exit_code);
 269   CloseHandle(p_internal->thread_id);
 270
 271   p_internal->state = STATE_IDLE;
 272
 273   return (void *)exit_code;
 274 }
 275
 276 unsigned long wxThread::GetID() const
 277 {
 278   return (unsigned long)p_internal->tid;
 279 }
 280
 281 bool wxThread::IsRunning() const
 282 {
 283   return (p_internal->state == STATE_RUNNING);
 284 }
 285
 286 bool wxThread::IsAlive() const
 287 {
 288   return (p_internal->state == STATE_RUNNING);
 289 }
 290
 291 bool wxThread::IsMain()
 292 {
 293   return (GetCurrentThread() == p_mainid);
 294 }
 295
 296 wxThread::wxThread()
 297 {
 298   p_internal = new wxThreadInternal();
 299
 300   p_internal->defer = FALSE;
 301   p_internal->prio  = WXTHREAD_DEFAULT_PRIORITY;
 302   p_internal->state = STATE_IDLE;
 303 }
 304
 305 wxThread::~wxThread()
 306 {
 307   Destroy();
 308   Join();
 309   delete p_internal;
 310 }
 311
 312 // The default callback just joins the thread and throws away the result.
 313 void wxThread::OnExit()
 314 {
 315   Join();
 316 }
 317
 318 // Automatic initialization
 319 class wxThreadModule : public wxModule {
 320   DECLARE_DYNAMIC_CLASS(wxThreadModule)
 321 public:
 322   virtual bool OnInit() {
 323     wxMainMutex = new wxMutex();
 324     p_mainid = GetCurrentThread();
 325     wxMainMutex->Lock();
 326     return TRUE;
 327   }
 328
 329   // Global cleanup
 330   virtual void OnExit() {
 331     wxMainMutex->Unlock();
 332     delete wxMainMutex;
 333   }
 334 };
 335
 336 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
 337