xpcom/base/StaticMutex.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_StaticMutex_h
   8 #define mozilla_StaticMutex_h
   9
  10 #include "mozilla/Atomics.h"
  11 #include "mozilla/Mutex.h"
  12
  13 namespace mozilla {
  14
  15 /**
  16  * StaticMutex is a Mutex that can (and in fact, must) be used as a
  17  * global/static variable.
  18  *
  19  * The main reason to use StaticMutex as opposed to
  20  * StaticAutoPtr<OffTheBooksMutex> is that we instantiate the StaticMutex in a
  21  * thread-safe manner the first time it's used.
  22  *
  23  * The same caveats that apply to StaticAutoPtr apply to StaticMutex.  In
  24  * particular, do not use StaticMutex as a stack variable or a class instance
  25  * variable, because this class relies on the fact that global variablies are
  26  * initialized to 0 in order to initialize mMutex.  It is only safe to use
  27  * StaticMutex as a global or static variable.
  28  */
  29 class MOZ_ONLY_USED_TO_AVOID_STATIC_CONSTRUCTORS MOZ_CAPABILITY("mutex")
  30     StaticMutex {
  31  public:
  32   // In debug builds, check that mMutex is initialized for us as we expect by
  33   // the compiler.  In non-debug builds, don't declare a constructor so that
  34   // the compiler can see that the constructor is trivial.
  35 #ifdef DEBUG
  36   StaticMutex() { MOZ_ASSERT(!mMutex); }
  37 #endif
  38
  39   void Lock() MOZ_CAPABILITY_ACQUIRE() { Mutex()->Lock(); }
  40
  41   void Unlock() MOZ_CAPABILITY_RELEASE() { Mutex()->Unlock(); }
  42
  43   void AssertCurrentThreadOwns() MOZ_ASSERT_CAPABILITY(this) {
  44 #ifdef DEBUG
  45     Mutex()->AssertCurrentThreadOwns();
  46 #endif
  47   }
  48
  49  private:
  50   OffTheBooksMutex* Mutex() {
  51     if (mMutex) {
  52       return mMutex;
  53     }
  54
  55     OffTheBooksMutex* mutex = new OffTheBooksMutex("StaticMutex");
  56     if (!mMutex.compareExchange(nullptr, mutex)) {
  57       delete mutex;
  58     }
  59
  60     return mMutex;
  61   }
  62
  63   Atomic<OffTheBooksMutex*, SequentiallyConsistent> mMutex;
  64
  65   // Disallow copy constructor, but only in debug mode.  We only define
  66   // a default constructor in debug mode (see above); if we declared
  67   // this constructor always, the compiler wouldn't generate a trivial
  68   // default constructor for us in non-debug mode.
  69 #ifdef DEBUG
  70   StaticMutex(StaticMutex& aOther);
  71 #endif
  72
  73   // Disallow these operators.
  74   StaticMutex& operator=(StaticMutex* aRhs);
  75   static void* operator new(size_t) noexcept(true);
  76   static void operator delete(void*);
  77 };
  78
  79 typedef detail::BaseAutoLock<StaticMutex&> StaticMutexAutoLock;
  80 typedef detail::BaseAutoUnlock<StaticMutex&> StaticMutexAutoUnlock;
  81
  82 }  // namespace mozilla
  83
  84 #endif