Thread safe lazy construction of a singleton in C++

by

Basically, you’re asking for synchronized creation of a singleton, without using any synchronization (previously-constructed variables). In general, no, this is not possible. You need something available for synchronization.

As for your other question, yes, static variables which can be statically initialized (i.e. no runtime code necessary) are guaranteed to be initialized before other code is executed. This makes it possible to use a statically-initialized mutex to synchronize creation of the singleton.

From the 2003 revision of the C++ standard:

Objects with static storage duration (3.7.1) shall be zero-initialized (8.5) before any other initialization takes place. Zero-initialization and initialization with a constant expression are collectively called static initialization; all other initialization is dynamic initialization. Objects of POD types (3.9) with static storage duration initialized with constant expressions (5.19) shall be initialized before any dynamic initialization takes place. Objects with static storage duration defined in namespace scope in the same translation unit and dynamically initialized shall be initialized in the order in which their definition appears in the translation unit.

If you know that you will be using this singleton during the initialization of other static objects, I think you’ll find that synchronization is a non-issue. To the best of my knowledge, all major compilers initialize static objects in a single thread, so thread-safety during static initialization. You can declare your singleton pointer to be NULL, and then check to see if it’s been initialized before you use it.

However, this assumes that you know that you’ll use this singleton during static initialization. This is also not guaranteed by the standard, so if you want to be completely safe, use a statically-initialized mutex.

Edit: Chris’s suggestion to use an atomic compare-and-swap would certainly work. If portability is not an issue (and creating additional temporary singletons is not a problem), then it is a slightly lower overhead solution.

More Related Contents:

  1. How to implement multithread safe singleton in C++11 without using
  2. Why is volatile not considered useful in multithreaded C or C++ programming?
  3. Simple example of threading in C++
  4. Concurrency: Atomic and volatile in C++11 memory model
  5. Programmatically find the number of cores on a machine
  6. How can I implement ABA counter with c++11 CAS?
  7. Using stdlib’s rand() from multiple threads
  8. Lock-free Progress Guarantees in a circular buffer queue
  9. What are the correct link options to use std::thread in GCC under linux?
  10. Are C++ Reads and Writes of an int Atomic?
  11. When should I use _mm_sfence _mm_lfence and _mm_mfence
  12. How to efficiently display OpenCV video in Qt?
  13. What’s the difference between “static” and “dynamic” schedule in OpenMP?
  14. Precise thread sleep needed. Max 1ms error
  15. Which std::async implementations use thread pools?
  16. What is the difference between packaged_task and async
  17. Is it ok to read a shared boolean flag without locking it when another thread may set it (at most once)?
  18. Boost::asio – how to interrupt a blocked tcp server thread?
  19. Why does Windows 10 start extra threads in my program?
  20. Can I use std::async without waiting for the future limitation?
  21. C++ terminate called without an active exception
  22. Singleton pattern in C++
  23. C++ – std::thread crashes upon execution
  24. C++11 std::threads vs posix threads
  25. Are C/C++ fundamental types atomic?
  26. How do I guarantee fast shutdown of my win32 app?
  27. std::thread calling method of class [duplicate]
  28. Why is the != operator not allowed with OpenMP?
  29. C++, static vs. namespace vs. singleton
  30. “Step over” when debugging multithreaded programs in Visual Studio

Leave a Comment