xpcom/threads/Monitor.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_Monitor_h
   8 #define mozilla_Monitor_h
   9
  10 #include "mozilla/CondVar.h"
  11 #include "mozilla/Mutex.h"
  12
  13 namespace mozilla {
  14
  15 /**
  16  * Monitor provides a *non*-reentrant monitor: *not* a Java-style
  17  * monitor.  If your code needs support for reentrancy, use
  18  * ReentrantMonitor instead.  (Rarely should reentrancy be needed.)
  19  *
  20  * Instead of directly calling Monitor methods, it's safer and simpler
  21  * to instead use the RAII wrappers MonitorAutoLock and
  22  * MonitorAutoUnlock.
  23  */
  24 class Monitor {
  25  public:
  26   explicit Monitor(const char* aName)
  27       : mMutex(aName), mCondVar(mMutex, "[Monitor.mCondVar]") {}
  28
  29   ~Monitor() = default;
  30
  31   void Lock() { mMutex.Lock(); }
  32   [[nodiscard]] bool TryLock() { return mMutex.TryLock(); }
  33   void Unlock() { mMutex.Unlock(); }
  34
  35   void Wait() { mCondVar.Wait(); }
  36   CVStatus Wait(TimeDuration aDuration) { return mCondVar.Wait(aDuration); }
  37
  38   void Notify() { mCondVar.Notify(); }
  39   void NotifyAll() { mCondVar.NotifyAll(); }
  40
  41   void AssertCurrentThreadOwns() const { mMutex.AssertCurrentThreadOwns(); }
  42
  43   void AssertNotCurrentThreadOwns() const {
  44     mMutex.AssertNotCurrentThreadOwns();
  45   }
  46
  47  private:
  48   Monitor();
  49   Monitor(const Monitor&);
  50   Monitor& operator=(const Monitor&);
  51
  52   Mutex mMutex;
  53   CondVar mCondVar;
  54 };
  55
  56 /**
  57  * Lock the monitor for the lexical scope instances of this class are
  58  * bound to (except for MonitorAutoUnlock in nested scopes).
  59  *
  60  * The monitor must be unlocked when instances of this class are
  61  * created.
  62  */
  63 class MOZ_STACK_CLASS MonitorAutoLock {
  64  public:
  65   explicit MonitorAutoLock(Monitor& aMonitor) : mMonitor(&aMonitor) {
  66     mMonitor->Lock();
  67   }
  68
  69   ~MonitorAutoLock() { mMonitor->Unlock(); }
  70
  71   void Wait() { mMonitor->Wait(); }
  72   CVStatus Wait(TimeDuration aDuration) { return mMonitor->Wait(aDuration); }
  73
  74   void Notify() { mMonitor->Notify(); }
  75   void NotifyAll() { mMonitor->NotifyAll(); }
  76
  77  private:
  78   MonitorAutoLock();
  79   MonitorAutoLock(const MonitorAutoLock&);
  80   MonitorAutoLock& operator=(const MonitorAutoLock&);
  81   static void* operator new(size_t) noexcept(true);
  82
  83   friend class MonitorAutoUnlock;
  84
  85   Monitor* mMonitor;
  86 };
  87
  88 /**
  89  * Unlock the monitor for the lexical scope instances of this class
  90  * are bound to (except for MonitorAutoLock in nested scopes).
  91  *
  92  * The monitor must be locked by the current thread when instances of
  93  * this class are created.
  94  */
  95 class MOZ_STACK_CLASS MonitorAutoUnlock {
  96  public:
  97   explicit MonitorAutoUnlock(Monitor& aMonitor) : mMonitor(&aMonitor) {
  98     mMonitor->Unlock();
  99   }
 100
 101   explicit MonitorAutoUnlock(MonitorAutoLock& aMonitorLock)
 102       : mMonitor(aMonitorLock.mMonitor) {
 103     mMonitor->Unlock();
 104   }
 105
 106   ~MonitorAutoUnlock() { mMonitor->Lock(); }
 107
 108  private:
 109   MonitorAutoUnlock();
 110   MonitorAutoUnlock(const MonitorAutoUnlock&);
 111   MonitorAutoUnlock& operator=(const MonitorAutoUnlock&);
 112   static void* operator new(size_t) noexcept(true);
 113
 114   Monitor* mMonitor;
 115 };
 116
 117 }  // namespace mozilla
 118
 119 #endif  // mozilla_Monitor_h