juce/source/src/threads/juce_Thread.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../core/juce_StandardHeader.h"
  27
  28 BEGIN_JUCE_NAMESPACE
  29
  30 #include "juce_Thread.h"
  31 #include "juce_SpinLock.h"
  32 #include "../core/juce_Time.h"
  33 #include "../containers/juce_Array.h"
  34
  35
  36 //==============================================================================
  37 class RunningThreadsList
  38 {
  39 public:
  40     RunningThreadsList()
  41     {
  42     }
  43
  44     ~RunningThreadsList()
  45     {
  46         // Some threads are still running! Make sure you stop all your
  47         // threads cleanly before your app quits!
  48         jassert (threads.size() == 0);
  49     }
  50
  51     void add (Thread* const thread)
  52     {
  53         const SpinLock::ScopedLockType sl (lock);
  54         jassert (! threads.contains (thread));
  55         threads.add (thread);
  56     }
  57
  58     void remove (Thread* const thread)
  59     {
  60         const SpinLock::ScopedLockType sl (lock);
  61         jassert (threads.contains (thread));
  62         threads.removeValue (thread);
  63     }
  64
  65     int size() const noexcept
  66     {
  67         return threads.size();
  68     }
  69
  70     Thread* getThreadWithID (const Thread::ThreadID targetID) const noexcept
  71     {
  72         const SpinLock::ScopedLockType sl (lock);
  73
  74         for (int i = threads.size(); --i >= 0;)
  75         {
  76             Thread* const t = threads.getUnchecked(i);
  77
  78             if (t->getThreadId() == targetID)
  79                 return t;
  80         }
  81
  82         return nullptr;
  83     }
  84
  85     void stopAll (const int timeOutMilliseconds)
  86     {
  87         signalAllThreadsToStop();
  88
  89         for (;;)
  90         {
  91             Thread* firstThread = getFirstThread();
  92
  93             if (firstThread != nullptr)
  94                 firstThread->stopThread (timeOutMilliseconds);
  95             else
  96                 break;
  97         }
  98     }
  99
 100     static RunningThreadsList& getInstance()
 101     {
 102         static RunningThreadsList runningThreads;
 103         return runningThreads;
 104     }
 105
 106 private:
 107     Array<Thread*> threads;
 108     SpinLock lock;
 109
 110     void signalAllThreadsToStop()
 111     {
 112         const SpinLock::ScopedLockType sl (lock);
 113
 114         for (int i = threads.size(); --i >= 0;)
 115             threads.getUnchecked(i)->signalThreadShouldExit();
 116     }
 117
 118     Thread* getFirstThread() const
 119     {
 120         const SpinLock::ScopedLockType sl (lock);
 121         return threads.getFirst();
 122     }
 123 };
 124
 125
 126 //==============================================================================
 127 void Thread::threadEntryPoint()
 128 {
 129     RunningThreadsList::getInstance().add (this);
 130
 131     JUCE_TRY
 132     {
 133         if (threadName_.isNotEmpty())
 134             setCurrentThreadName (threadName_);
 135
 136         if (startSuspensionEvent_.wait (10000))
 137         {
 138             jassert (getCurrentThreadId() == threadId_);
 139
 140             if (affinityMask_ != 0)
 141                 setCurrentThreadAffinityMask (affinityMask_);
 142
 143             run();
 144         }
 145     }
 146     JUCE_CATCH_ALL_ASSERT
 147
 148     RunningThreadsList::getInstance().remove (this);
 149     closeThreadHandle();
 150 }
 151
 152 // used to wrap the incoming call from the platform-specific code
 153 void JUCE_API juce_threadEntryPoint (void* userData)
 154 {
 155     static_cast <Thread*> (userData)->threadEntryPoint();
 156 }
 157
 158
 159 //==============================================================================
 160 Thread::Thread (const String& threadName)
 161     : threadName_ (threadName),
 162       threadHandle_ (nullptr),
 163       threadId_ (0),
 164       threadPriority_ (5),
 165       affinityMask_ (0),
 166       threadShouldExit_ (false)
 167 {
 168 }
 169
 170 Thread::~Thread()
 171 {
 172     /* If your thread class's destructor has been called without first stopping the thread, that
 173        means that this partially destructed object is still performing some work - and that's
 174        probably a Bad Thing!
 175
 176        To avoid this type of nastiness, always make sure you call stopThread() before or during
 177        your subclass's destructor.
 178     */
 179     jassert (! isThreadRunning());
 180
 181     stopThread (100);
 182 }
 183
 184 //==============================================================================
 185 void Thread::startThread()
 186 {
 187     const ScopedLock sl (startStopLock);
 188
 189     threadShouldExit_ = false;
 190
 191     if (threadHandle_ == nullptr)
 192     {
 193         launchThread();
 194         setThreadPriority (threadHandle_, threadPriority_);
 195         startSuspensionEvent_.signal();
 196     }
 197 }
 198
 199 void Thread::startThread (const int priority)
 200 {
 201     const ScopedLock sl (startStopLock);
 202
 203     if (threadHandle_ == nullptr)
 204     {
 205         threadPriority_ = priority;
 206         startThread();
 207     }
 208     else
 209     {
 210         setPriority (priority);
 211     }
 212 }
 213
 214 bool Thread::isThreadRunning() const
 215 {
 216     return threadHandle_ != nullptr;
 217 }
 218
 219 //==============================================================================
 220 void Thread::signalThreadShouldExit()
 221 {
 222     threadShouldExit_ = true;
 223 }
 224
 225 bool Thread::waitForThreadToExit (const int timeOutMilliseconds) const
 226 {
 227     // Doh! So how exactly do you expect this thread to wait for itself to stop??
 228     jassert (getThreadId() != getCurrentThreadId());
 229
 230     const int sleepMsPerIteration = 5;
 231     int count = timeOutMilliseconds / sleepMsPerIteration;
 232
 233     while (isThreadRunning())
 234     {
 235         if (timeOutMilliseconds > 0 && --count < 0)
 236             return false;
 237
 238         sleep (sleepMsPerIteration);
 239     }
 240
 241     return true;
 242 }
 243
 244 void Thread::stopThread (const int timeOutMilliseconds)
 245 {
 246     // agh! You can't stop the thread that's calling this method! How on earth
 247     // would that work??
 248     jassert (getCurrentThreadId() != getThreadId());
 249
 250     const ScopedLock sl (startStopLock);
 251
 252     if (isThreadRunning())
 253     {
 254         signalThreadShouldExit();
 255         notify();
 256
 257         if (timeOutMilliseconds != 0)
 258             waitForThreadToExit (timeOutMilliseconds);
 259
 260         if (isThreadRunning())
 261         {
 262             // very bad karma if this point is reached, as there are bound to be
 263             // locks and events left in silly states when a thread is killed by force..
 264             jassertfalse;
 265             Logger::writeToLog ("!! killing thread by force !!");
 266
 267             killThread();
 268
 269             RunningThreadsList::getInstance().remove (this);
 270             threadHandle_ = nullptr;
 271             threadId_ = 0;
 272         }
 273     }
 274 }
 275
 276 //==============================================================================
 277 bool Thread::setPriority (const int priority)
 278 {
 279     const ScopedLock sl (startStopLock);
 280
 281     if (setThreadPriority (threadHandle_, priority))
 282     {
 283         threadPriority_ = priority;
 284         return true;
 285     }
 286
 287     return false;
 288 }
 289
 290 bool Thread::setCurrentThreadPriority (const int priority)
 291 {
 292     return setThreadPriority (0, priority);
 293 }
 294
 295 void Thread::setAffinityMask (const uint32 affinityMask)
 296 {
 297     affinityMask_ = affinityMask;
 298 }
 299
 300 //==============================================================================
 301 bool Thread::wait (const int timeOutMilliseconds) const
 302 {
 303     return defaultEvent_.wait (timeOutMilliseconds);
 304 }
 305
 306 void Thread::notify() const
 307 {
 308     defaultEvent_.signal();
 309 }
 310
 311 //==============================================================================
 312 int Thread::getNumRunningThreads()
 313 {
 314     return RunningThreadsList::getInstance().size();
 315 }
 316
 317 Thread* Thread::getCurrentThread()
 318 {
 319     return RunningThreadsList::getInstance().getThreadWithID (getCurrentThreadId());
 320 }
 321
 322 void Thread::stopAllThreads (const int timeOutMilliseconds)
 323 {
 324     RunningThreadsList::getInstance().stopAll (timeOutMilliseconds);
 325 }
 326
 327 //==============================================================================
 328 void SpinLock::enter() const noexcept
 329 {
 330     if (! tryEnter())
 331     {
 332         for (int i = 20; --i >= 0;)
 333             if (tryEnter())
 334                 return;
 335
 336         while (! tryEnter())
 337             Thread::yield();
 338     }
 339 }
 340
 341
 342 END_JUCE_NAMESPACE