juce/source/src/threads/juce_ReadWriteLock.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_ReadWriteLock.h"
  31 #include "juce_Thread.h"
  32
  33
  34 //==============================================================================
  35 ReadWriteLock::ReadWriteLock() noexcept
  36     : numWaitingWriters (0),
  37       numWriters (0),
  38       writerThreadId (0)
  39 {
  40 }
  41
  42 ReadWriteLock::~ReadWriteLock() noexcept
  43 {
  44     jassert (readerThreads.size() == 0);
  45     jassert (numWriters == 0);
  46 }
  47
  48 //==============================================================================
  49 void ReadWriteLock::enterRead() const noexcept
  50 {
  51     const Thread::ThreadID threadId = Thread::getCurrentThreadId();
  52     const SpinLock::ScopedLockType sl (accessLock);
  53
  54     for (;;)
  55     {
  56         jassert (readerThreads.size() % 2 == 0);
  57
  58         int i;
  59         for (i = 0; i < readerThreads.size(); i += 2)
  60             if (readerThreads.getUnchecked(i) == threadId)
  61                 break;
  62
  63         if (i < readerThreads.size()
  64               || numWriters + numWaitingWriters == 0
  65               || (threadId == writerThreadId && numWriters > 0))
  66         {
  67             if (i < readerThreads.size())
  68             {
  69                 readerThreads.set (i + 1, (Thread::ThreadID) (1 + (pointer_sized_int) readerThreads.getUnchecked (i + 1)));
  70             }
  71             else
  72             {
  73                 readerThreads.add (threadId);
  74                 readerThreads.add ((Thread::ThreadID) 1);
  75             }
  76
  77             return;
  78         }
  79
  80         const SpinLock::ScopedUnlockType ul (accessLock);
  81         waitEvent.wait (100);
  82     }
  83 }
  84
  85 void ReadWriteLock::exitRead() const noexcept
  86 {
  87     const Thread::ThreadID threadId = Thread::getCurrentThreadId();
  88     const SpinLock::ScopedLockType sl (accessLock);
  89
  90     for (int i = 0; i < readerThreads.size(); i += 2)
  91     {
  92         if (readerThreads.getUnchecked(i) == threadId)
  93         {
  94             const pointer_sized_int newCount = ((pointer_sized_int) readerThreads.getUnchecked (i + 1)) - 1;
  95
  96             if (newCount == 0)
  97             {
  98                 readerThreads.removeRange (i, 2);
  99                 waitEvent.signal();
 100             }
 101             else
 102             {
 103                 readerThreads.set (i + 1, (Thread::ThreadID) newCount);
 104             }
 105
 106             return;
 107         }
 108     }
 109
 110     jassertfalse; // unlocking a lock that wasn't locked..
 111 }
 112
 113 //==============================================================================
 114 void ReadWriteLock::enterWrite() const noexcept
 115 {
 116     const Thread::ThreadID threadId = Thread::getCurrentThreadId();
 117     const SpinLock::ScopedLockType sl (accessLock);
 118
 119     for (;;)
 120     {
 121         if (readerThreads.size() + numWriters == 0
 122              || threadId == writerThreadId
 123              || (readerThreads.size() == 2
 124                   && readerThreads.getUnchecked(0) == threadId))
 125         {
 126             writerThreadId = threadId;
 127             ++numWriters;
 128             break;
 129         }
 130
 131         ++numWaitingWriters;
 132         accessLock.exit();
 133         waitEvent.wait (100);
 134         accessLock.enter();
 135         --numWaitingWriters;
 136     }
 137 }
 138
 139 bool ReadWriteLock::tryEnterWrite() const noexcept
 140 {
 141     const Thread::ThreadID threadId = Thread::getCurrentThreadId();
 142     const SpinLock::ScopedLockType sl (accessLock);
 143
 144     if (readerThreads.size() + numWriters == 0
 145          || threadId == writerThreadId
 146          || (readerThreads.size() == 2
 147               && readerThreads.getUnchecked(0) == threadId))
 148     {
 149         writerThreadId = threadId;
 150         ++numWriters;
 151         return true;
 152     }
 153
 154     return false;
 155 }
 156
 157 void ReadWriteLock::exitWrite() const noexcept
 158 {
 159     const SpinLock::ScopedLockType sl (accessLock);
 160
 161     // check this thread actually had the lock..
 162     jassert (numWriters > 0 && writerThreadId == Thread::getCurrentThreadId());
 163
 164     if (--numWriters == 0)
 165     {
 166         writerThreadId = 0;
 167         waitEvent.signal();
 168     }
 169 }
 170
 171 END_JUCE_NAMESPACE