juce/source/src/threads/juce_TimeSliceThread.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_TimeSliceThread.h"
  31
  32
  33 //==============================================================================
  34 TimeSliceThread::TimeSliceThread (const String& threadName)
  35     : Thread (threadName),
  36       clientBeingCalled (nullptr)
  37 {
  38 }
  39
  40 TimeSliceThread::~TimeSliceThread()
  41 {
  42     stopThread (2000);
  43 }
  44
  45 //==============================================================================
  46 void TimeSliceThread::addTimeSliceClient (TimeSliceClient* const client, int millisecondsBeforeStarting)
  47 {
  48     if (client != nullptr)
  49     {
  50         const ScopedLock sl (listLock);
  51         client->nextCallTime = Time::getCurrentTime() + RelativeTime::milliseconds (millisecondsBeforeStarting);
  52         clients.addIfNotAlreadyThere (client);
  53         notify();
  54     }
  55 }
  56
  57 void TimeSliceThread::removeTimeSliceClient (TimeSliceClient* const client)
  58 {
  59     const ScopedLock sl1 (listLock);
  60
  61     // if there's a chance we're in the middle of calling this client, we need to
  62     // also lock the outer lock..
  63     if (clientBeingCalled == client)
  64     {
  65         const ScopedUnlock ul (listLock); // unlock first to get the order right..
  66
  67         const ScopedLock sl2 (callbackLock);
  68         const ScopedLock sl3 (listLock);
  69
  70         clients.removeValue (client);
  71     }
  72     else
  73     {
  74         clients.removeValue (client);
  75     }
  76 }
  77
  78 int TimeSliceThread::getNumClients() const
  79 {
  80     return clients.size();
  81 }
  82
  83 TimeSliceClient* TimeSliceThread::getClient (const int i) const
  84 {
  85     const ScopedLock sl (listLock);
  86     return clients [i];
  87 }
  88
  89 //==============================================================================
  90 TimeSliceClient* TimeSliceThread::getNextClient (int index) const
  91 {
  92     Time soonest;
  93     TimeSliceClient* client = nullptr;
  94
  95     for (int i = clients.size(); --i >= 0;)
  96     {
  97         TimeSliceClient* const c = clients.getUnchecked ((i + index) % clients.size());
  98
  99         if (client == nullptr || c->nextCallTime < soonest)
 100         {
 101             client = c;
 102             soonest = c->nextCallTime;
 103         }
 104     }
 105
 106     return client;
 107 }
 108
 109 void TimeSliceThread::run()
 110 {
 111     int index = 0;
 112
 113     while (! threadShouldExit())
 114     {
 115         int timeToWait = 500;
 116
 117         {
 118             Time nextClientTime;
 119
 120             {
 121                 const ScopedLock sl2 (listLock);
 122
 123                 index = clients.size() > 0 ? ((index + 1) % clients.size()) : 0;
 124
 125                 TimeSliceClient* const firstClient = getNextClient (index);
 126                 if (firstClient != nullptr)
 127                     nextClientTime = firstClient->nextCallTime;
 128             }
 129
 130             const Time now (Time::getCurrentTime());
 131
 132             if (nextClientTime > now)
 133             {
 134                 timeToWait = (int) jmin ((int64) 500, (nextClientTime - now).inMilliseconds());
 135             }
 136             else
 137             {
 138                 timeToWait = index == 0 ? 1 : 0;
 139
 140                 const ScopedLock sl (callbackLock);
 141
 142                 {
 143                     const ScopedLock sl2 (listLock);
 144                     clientBeingCalled = getNextClient (index);
 145                 }
 146
 147                 if (clientBeingCalled != nullptr)
 148                 {
 149                     const int msUntilNextCall = clientBeingCalled->useTimeSlice();
 150
 151                     const ScopedLock sl2 (listLock);
 152
 153                     if (msUntilNextCall >= 0)
 154                         clientBeingCalled->nextCallTime += RelativeTime::milliseconds (msUntilNextCall);
 155                     else
 156                         clients.removeValue (clientBeingCalled);
 157
 158                     clientBeingCalled = nullptr;
 159                 }
 160             }
 161         }
 162
 163         if (timeToWait > 0)
 164             wait (timeToWait);
 165     }
 166 }
 167
 168
 169 END_JUCE_NAMESPACE