LazyInstance should be thread safe by default.

src/lazy-instance.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 48 matching lines @@
 // Example usage:
 //   struct MyCreateTrait {
 //     static void Construct(MyClass* allocated_ptr) {
 //       new (allocated_ptr) MyClass(/* extra parameters... */);
 //     }
 //   };
 //   static LazyInstance<MyClass, MyCreateTrait>::type my_instance =
 //      LAZY_INSTANCE_INITIALIZER;
 //
 // WARNINGS:
-// - This implementation of LazyInstance is NOT THREAD-SAFE by default. See
-//   ThreadSafeInitOnceTrait declared below for that.
+// - This implementation of LazyInstance IS THREAD-SAFE by default. See
+//   SingleThreadInitOnceTrait if you don't care about thread safety.
 // - Lazy initialization comes with a cost. Make sure that you don't use it on
 //   critical path. Consider adding your initialization code to a function
 //   which is explicitly called once.
 //
 // Notes for advanced users:
 // LazyInstance can actually be used in two different ways:
 //
 // - "Static mode" which is the default mode since it is the most efficient
 //   (no extra heap allocation). In this mode, the instance is statically
 //   allocated (stored in the global data section at compile time).
@@ skipping 86 matching lines @@
 
 struct ThreadSafeInitOnceTrait {
   template <typename Function, typename Storage>
   static void Init(OnceType* once, Function function, Storage storage) {
     CallOnce(once, function, storage);
   }
 };
 
 
 // Initialization trait for users who don't care about thread-safety.
+//
+// Thank you for making this the default, Satan.

[Hannes Payer (out of office), 2014/04/16 07:56:56]

Very entertaining, but we should probably not have Satan in our code base :)

 struct SingleThreadInitOnceTrait {
   template <typename Function, typename Storage>
   static void Init(OnceType* once, Function function, Storage storage) {
     if (*once == ONCE_STATE_UNINITIALIZED) {
       function(storage);
       *once = ONCE_STATE_DONE;
     }
   }
 };
 
@@ skipping 33 matching lines @@
   mutable OnceType once_;
   // Note that the previous field, OnceType, is an AtomicWord which guarantees
   // 4-byte alignment of the storage field below. If compiling with GCC (>4.2),
   // the LAZY_ALIGN macro above will guarantee correctness for any alignment.
   mutable StorageType storage_;
 };
 
 
 template <typename T,
           typename CreateTrait = DefaultConstructTrait<T>,
-          typename InitOnceTrait = SingleThreadInitOnceTrait,
+          typename InitOnceTrait = ThreadSafeInitOnceTrait,
           typename DestroyTrait = LeakyInstanceTrait<T> >
 struct LazyStaticInstance {
   typedef LazyInstanceImpl<T, StaticallyAllocatedInstanceTrait<T>,
       CreateTrait, InitOnceTrait, DestroyTrait> type;
 };
 
 
 template <typename T,
           typename CreateTrait = DefaultConstructTrait<T>,
-          typename InitOnceTrait = SingleThreadInitOnceTrait,
+          typename InitOnceTrait = ThreadSafeInitOnceTrait,
           typename DestroyTrait = LeakyInstanceTrait<T> >
 struct LazyInstance {
   // A LazyInstance is a LazyStaticInstance.
   typedef typename LazyStaticInstance<T, CreateTrait, InitOnceTrait,
       DestroyTrait>::type type;
 };
 
 
 template <typename T,
           typename CreateTrait = DefaultCreateTrait<T>,
-          typename InitOnceTrait = SingleThreadInitOnceTrait,
+          typename InitOnceTrait = ThreadSafeInitOnceTrait,
           typename DestroyTrait = LeakyInstanceTrait<T> >
 struct LazyDynamicInstance {
   typedef LazyInstanceImpl<T, DynamicallyAllocatedInstanceTrait<T>,
       CreateTrait, InitOnceTrait, DestroyTrait> type;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_LAZY_INSTANCE_H_