base/lazy_instance.h

   1 // Copyright (c) 2008 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // The LazyInstance<Type, Traits> class manages a single instance of Type,
   6 // which will be lazily created on the first time it's accessed.  This class is
   7 // useful for places you would normally use a function-level static, but you
   8 // need to have guaranteed thread-safety.  The Type constructor will only ever
   9 // be called once, even if two threads are racing to create the object.  Get()
  10 // and Pointer() will always return the same, completely initialized instance.
  11 // When the instance is constructed it is registered with AtExitManager.  The
  12 // destructor will be called on program exit.
  13 //
  14 // LazyInstance is completely thread safe, assuming that you create it safely.
  15 // The class was designed to be POD initialized, so it shouldn't require a
  16 // static constructor.  It really only makes sense to declare a LazyInstance as
  17 // a global variable using the base::LinkerInitialized constructor.
  18 //
  19 // LazyInstance is similar to Singleton, except it does not have the singleton
  20 // property.  You can have multiple LazyInstance's of the same type, and each
  21 // will manage a unique instance.  It also preallocates the space for Type, as
  22 // to avoid allocating the Type instance on the heap.  This may help with the
  23 // performance of creating the instance, and reducing heap fragmentation.  This
  24 // requires that Type be a complete type so we can determine the size.
  25 //
  26 // Example usage:
  27 //   static LazyInstance<MyClass> my_instance(base::LINKER_INITIALIZED);
  28 //   void SomeMethod() {
  29 //     my_instance.Get().SomeMethod();  // MyClass::SomeMethod()
  30 //
  31 //     MyClass* ptr = my_instance.Pointer();
  32 //     ptr->DoDoDo();  // MyClass::DoDoDo
  33 //   }
  34
  35 #ifndef BASE_LAZY_INSTANCE_H_
  36 #define BASE_LAZY_INSTANCE_H_
  37 #pragma once
  38
  39 #include <new>  // For placement new.
  40
  41 #include "base/atomicops.h"
  42 #include "base/basictypes.h"
  43 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
  44 #include "base/threading/thread_restrictions.h"
  45
  46 namespace base {
  47
  48 template <typename Type>
  49 struct DefaultLazyInstanceTraits {
  50   static const bool kAllowedToAccessOnNonjoinableThread = false;
  51
  52   static Type* New(void* instance) {
  53     // Use placement new to initialize our instance in our preallocated space.
  54     // The parenthesis is very important here to force POD type initialization.
  55     return new (instance) Type();
  56   }
  57   static void Delete(void* instance) {
  58     // Explicitly call the destructor.
  59     reinterpret_cast<Type*>(instance)->~Type();
  60   }
  61 };
  62
  63 template <typename Type>
  64 struct LeakyLazyInstanceTraits {
  65   static const bool kAllowedToAccessOnNonjoinableThread = true;
  66
  67   static Type* New(void* instance) {
  68     return DefaultLazyInstanceTraits<Type>::New(instance);
  69   }
  70   // Rather than define an empty Delete function, we make Delete itself
  71   // a null pointer.  This allows us to completely sidestep registering
  72   // this object with an AtExitManager, which allows you to use
  73   // LeakyLazyInstanceTraits in contexts where you don't have an
  74   // AtExitManager.
  75   static void (*Delete)(void* instance);
  76 };
  77
  78 template <typename Type>
  79 void (*LeakyLazyInstanceTraits<Type>::Delete)(void* instance) = NULL;
  80
  81 // We pull out some of the functionality into a non-templated base, so that we
  82 // can implement the more complicated pieces out of line in the .cc file.
  83 class LazyInstanceHelper {
  84  protected:
  85   enum {
  86     STATE_EMPTY    = 0,
  87     STATE_CREATING = 1,
  88     STATE_CREATED  = 2
  89   };
  90
  91   explicit LazyInstanceHelper(LinkerInitialized x) { /* state_ is 0 */ }
  92   // Declaring a destructor (even if it's empty) will cause MSVC to register a
  93   // static initializer to register the empty destructor with atexit().
  94
  95   // Check if instance needs to be created. If so return true otherwise
  96   // if another thread has beat us, wait for instance to be created and
  97   // return false.
  98   bool NeedsInstance();
  99
 100   // After creating an instance, call this to register the dtor to be called
 101   // at program exit and to update the state to STATE_CREATED.
 102   void CompleteInstance(void* instance, void (*dtor)(void*));
 103
 104   base::subtle::Atomic32 state_;
 105
 106  private:
 107   DISALLOW_COPY_AND_ASSIGN(LazyInstanceHelper);
 108 };
 109
 110 template <typename Type, typename Traits = DefaultLazyInstanceTraits<Type> >
 111 class LazyInstance : public LazyInstanceHelper {
 112  public:
 113   explicit LazyInstance(LinkerInitialized x) : LazyInstanceHelper(x) { }
 114   // Declaring a destructor (even if it's empty) will cause MSVC to register a
 115   // static initializer to register the empty destructor with atexit().
 116
 117   Type& Get() {
 118     return *Pointer();
 119   }
 120
 121   Type* Pointer() {
 122     if (!Traits::kAllowedToAccessOnNonjoinableThread)
 123       base::ThreadRestrictions::AssertSingletonAllowed();
 124
 125     // We will hopefully have fast access when the instance is already created.
 126     if ((base::subtle::NoBarrier_Load(&state_) != STATE_CREATED) &&
 127         NeedsInstance()) {
 128       // Create the instance in the space provided by |buf_|.
 129       instance_ = Traits::New(buf_);
 130       // Traits::Delete will be null for LeakyLazyInstannceTraits
 131       void (*dtor)(void*) = Traits::Delete;
 132       CompleteInstance(this, (dtor == NULL) ? NULL : OnExit);
 133     }
 134
 135     // This annotation helps race detectors recognize correct lock-less
 136     // synchronization between different threads calling Pointer().
 137     // We suggest dynamic race detection tool that "Traits::New" above
 138     // and CompleteInstance(...) happens before "return instance_" below.
 139     // See the corresponding HAPPENS_BEFORE in CompleteInstance(...).
 140     ANNOTATE_HAPPENS_AFTER(&state_);
 141     return instance_;
 142   }
 143
 144  private:
 145   // Adapter function for use with AtExit.  This should be called single
 146   // threaded, so don't use atomic operations.
 147   // Calling OnExit while the instance is in use by other threads is a mistake.
 148   static void OnExit(void* lazy_instance) {
 149     LazyInstance<Type, Traits>* me =
 150         reinterpret_cast<LazyInstance<Type, Traits>*>(lazy_instance);
 151     Traits::Delete(me->instance_);
 152     me->instance_ = NULL;
 153     base::subtle::Release_Store(&me->state_, STATE_EMPTY);
 154   }
 155
 156   int8 buf_[sizeof(Type)];  // Preallocate the space for the Type instance.
 157   Type *instance_;
 158
 159   DISALLOW_COPY_AND_ASSIGN(LazyInstance);
 160 };
 161
 162 }  // namespace base
 163
 164 #endif  // BASE_LAZY_INSTANCE_H_