{"id":4885,"date":"2016-08-23T05:49:48","date_gmt":"2016-08-23T05:49:48","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/thread-safe-initialization-of-a-singleton\/"},"modified":"2023-06-26T12:44:42","modified_gmt":"2023-06-26T12:44:42","slug":"thread-safe-initialization-of-a-singleton","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/thread-safe-initialization-of-a-singleton\/","title":{"rendered":"Thread-Safe Initialization of a Singleton"},"content":{"rendered":"

There are a lot of issues with the singleton pattern. I’m aware of that. But the singleton pattern is an ideal use case for a variable, which can only be initialized in a thread-safe way. From that point on, you can use it without synchronization. So in this post, I discuss different ways to initialize a singleton in a multithreading environment. You get the performance numbers and can reason about your use cases for the thread-safe initialization of a variable.<\/p>\n

<\/p>\n

 <\/p>\n

There are many different ways to initialize a singleton in C++11 in a thread-safe way. From a birds-eye, you can have guarantees from the C++ runtime, locks, or atomics. I’m totally curious about the performance implications.<\/p>\n

<\/span>My strategy<\/span><\/h2>\n

As a reference point for my performance measurement, I use a singleton object which I sequential access 40 million times. The first access will initialize the object. In contrast, the access from the multithreading program will be done by four threads. Here I’m only interested in the performance. The program will run on two real PCs. My Linux PC has four; my Windows PC has two cores. I compile the program with maximum and without optimization. To translate the program with maximum optimization, I have to use a volatile<\/span> variable in the static method getInstance<\/span>. If not, the compiler will optimize away my access to the singleton, and my program becomes too fast.<\/p>\n

I have three questions in my mind:<\/p>\n

    \n
  1. What is the relative performance of the different singleton implementations?<\/li>\n
  2. Is there a significant difference between Linux (GCC) and Windows (cl.exe)?<\/li>\n
  3. What’s the difference between the optimized and non-optimized versions?<\/li>\n<\/ol>\n

    Finally, I collect all numbers in a table. The numbers are in seconds.<\/p>\n<\/p>\n

    <\/span>The reference values<\/span><\/h2>\n

    <\/span>The both compilers<\/span><\/h3>\n

    The command line gives you the details of the compiler Here are the gcc and the cl.exe.<\/p>\n

    \"gcc\"\"cl<\/p>\n

    <\/span>The reference code<\/span><\/h3>\n

    At first, the single-threaded case. Of course, without synchronization.<\/p>\n

    <\/p>\n

    \n\n\n\n
    \n
     1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37<\/pre>\n<\/td>\n
    		\n
    \/\/ singletonSingleThreaded.cpp<\/span>\r\n\r\n#include <chrono><\/span>\r\n#include <iostream><\/span>\r\n\r\nconstexpr auto<\/span> tenMill= 10000000;\r\n\r\nclass<\/span> MySingleton<\/span>{\r\npublic:\r\n  static<\/span> MySingleton& getInstance(){\r\n    static<\/span> MySingleton instance;\r\n    \/\/ volatile int dummy{};<\/span>\r\n    return<\/span> instance;\r\n  }\r\nprivate:\r\n  MySingleton()= default<\/span>;\r\n  ~MySingleton()= default<\/span>;\r\n  MySingleton(const<\/span> MySingleton&)= delete<\/span>;\r\n  MySingleton& operator<\/span>=(const<\/span> MySingleton&)= delete<\/span>;\r\n  \r\n};\r\n\r\nint<\/span> main(){\r\n    \r\n  constexpr auto<\/span> fourtyMill= 4* tenMill;\r\n  \r\n  auto<\/span> begin= std::chrono::system_clock::now();\r\n  \r\n  for<\/span> ( size_t<\/span> i= 0; i <= fourtyMill; ++i){\r\n       MySingleton::getInstance();\r\n  }\r\n  \r\n  auto<\/span> end= std::chrono::system_clock::now() - begin;\r\n  \r\n  std::cout << std::chrono::duration<double<\/span>>(end).count() << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
     <\/p>\n
    I use in the reference implementation the so-called Meyers Singleton. The elegance of this implementation is that the singleton object instance<\/span> in line 11 is a static variable with block scope. Therefore, instance<\/span> will exactly be initialized when the static method getInstance<\/span> (lines 10 – 14) will be executed the first time. In line 14, the volatile<\/span> variable dummy<\/span> is commented out. When I translate the program with maximum optimization, that has to change, so the call MySingleton::getInstance()<\/span> will not be optimized away. <\/p>\n
    Now the raw numbers on Linux and Windows.<\/p>\n
    Without optimization<\/h4>\n
    \"singletonSingleThreaded\"\"singletonSingleThreaded<\/p>\n
    Maximum Optimization<\/h4>\n
     \"singletonSingleThreaded\"singletonSingleThreaded<\/p>\n
    <\/span>Guarantees of the C++ runtime<\/span><\/h2>\n
    I already presented the details to the thread-safe initialization of variables in the post Thread-safe initialization of data. <\/a><\/p>\n
    <\/span>Meyers Singleton<\/span><\/h3>\n
    The beauty of the Meyers Singleton in C++11 is that it’s automatically thread-safe. That is guaranteed by the standard: Static variables with block scope. <\/a>The Meyers Singleton is a static variable with block scope, so we are done. It’s still left to rewrite the program for four threads.<\/p>\n
     <\/p>\n
    <\/p>\n
    \n\n\n\n
    \n
     1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45<\/pre>\n<\/td>\n
    		\n
    \/\/ singletonMeyers.cpp<\/span>\r\n\r\n#include <chrono><\/span>\r\n#include <iostream><\/span>\r\n#include <future><\/span>\r\n\r\nconstexpr auto<\/span> tenMill= 10000000;\r\n\r\nclass<\/span> MySingleton<\/span>{\r\npublic:\r\n  static<\/span> MySingleton& getInstance(){\r\n    static<\/span> MySingleton instance;\r\n    \/\/ volatile int dummy{};<\/span>\r\n    return<\/span> instance;\r\n  }\r\nprivate:\r\n  MySingleton()= default<\/span>;\r\n  ~MySingleton()= default<\/span>;\r\n  MySingleton(const<\/span> MySingleton&)= delete<\/span>;\r\n  MySingleton& operator<\/span>=(const<\/span> MySingleton&)= delete<\/span>;\r\n\r\n};\r\n\r\nstd::chrono::duration<double<\/span>> getTime(){\r\n\r\n  auto<\/span> begin= std::chrono::system_clock::now();\r\n  for<\/span> ( size_t<\/span> i= 0; i <= tenMill; ++i){\r\n      MySingleton::getInstance();\r\n  }\r\n  return<\/span> std::chrono::system_clock::now() - begin;\r\n  \r\n};\r\n\r\nint<\/span> main(){\r\n \r\n    auto<\/span> fut1= std::async(std::launch::async,getTime);\r\n    auto<\/span> fut2= std::async(std::launch::async,getTime);\r\n    auto<\/span> fut3= std::async(std::launch::async,getTime);\r\n    auto<\/span> fut4= std::async(std::launch::async,getTime);\r\n    \r\n    auto<\/span> total= fut1.get() + fut2.get() + fut3.get() + fut4.get();\r\n    \r\n    std::cout << total.count() << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
     <\/p>\n
    I use the singleton object in the function getTime<\/span> (lines 24 – 32). The function is executed by the four promise<\/span><\/a> in lines 36 – 39. The results of the associate futures<\/span><\/a> are summed up in line 41. That’s all. Only the execution time is missing.<\/p>\n
    Without optimization<\/h4>\n
     \"singletonMeyers\"\"singletonMeyers<\/p>\n
    Maximum optimization<\/h4>\n
    \"singletonMeyers\"singletonMeyers<\/p>\n
    The next step is the function std::call_once<\/span> in combination with the flag std::once_flag.<\/span><\/span>
    <\/span><\/p>\n
    <\/span>The function std::call_once and the flag std::once_flag<\/span><\/h2>\n
    You can use the function std::call_once<\/a> <\/span>to register a callable executed exactly once. The flag std::call_once<\/span> in the following implementation guarantees that the singleton will be thread-safe initialized.<\/p>\n
     <\/p>\n
    <\/p>\n
    \n\n\n\n
    \n
     1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45\r\n46\r\n47\r\n48\r\n49\r\n50\r\n51\r\n52\r\n53\r\n54\r\n55\r\n56<\/pre>\n<\/td>\n
    		\n
    \/\/ singletonCallOnce.cpp<\/span>\r\n\r\n#include <chrono><\/span>\r\n#include <iostream><\/span>\r\n#include <future><\/span>\r\n#include <mutex><\/span>\r\n#include <thread><\/span>\r\n\r\nconstexpr auto<\/span> tenMill= 10000000;\r\n\r\nclass<\/span> MySingleton<\/span>{\r\npublic:\r\n  static<\/span> MySingleton& getInstance(){\r\n    std::call_once(initInstanceFlag, &MySingleton::initSingleton);\r\n    \/\/ volatile int dummy{};<\/span>\r\n    return<\/span> *instance;\r\n  }\r\nprivate:\r\n  MySingleton()= default<\/span>;\r\n  ~MySingleton()= default<\/span>;\r\n  MySingleton(const<\/span> MySingleton&)= delete<\/span>;\r\n  MySingleton& operator<\/span>=(const<\/span> MySingleton&)= delete<\/span>;\r\n\r\n  static<\/span> MySingleton* instance;\r\n  static<\/span> std::once_flag initInstanceFlag;\r\n\r\n  static<\/span> void<\/span> initSingleton(){\r\n    instance= new<\/span> MySingleton;\r\n  }\r\n};\r\n\r\nMySingleton* MySingleton::instance= nullptr;\r\nstd::once_flag MySingleton::initInstanceFlag;\r\n\r\nstd::chrono::duration<double<\/span>> getTime(){\r\n\r\n  auto<\/span> begin= std::chrono::system_clock::now();\r\n  for<\/span> ( size_t<\/span> i= 0; i <= tenMill; ++i){\r\n      MySingleton::getInstance();\r\n  }\r\n  return<\/span> std::chrono::system_clock::now() - begin;\r\n  \r\n};\r\n\r\nint<\/span> main(){\r\n\r\n    auto<\/span> fut1= std::async(std::launch::async,getTime);\r\n    auto<\/span> fut2= std::async(std::launch::async,getTime);\r\n    auto<\/span> fut3= std::async(std::launch::async,getTime);\r\n    auto<\/span> fut4= std::async(std::launch::async,getTime);\r\n    \r\n    auto<\/span> total= fut1.get() + fut2.get() + fut3.get() + fut4.get();\r\n    \r\n    std::cout << total.count() << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
     <\/p>\n
    Here are the numbers.<\/p>\n
    Without optimization<\/h4>\n
    \"singletoCallOnce\"\"singletoCallOnce<\/p>\n
    Maximum optimization<\/h4>\n
    \"singletoCallOnce\"singletoCallOnce<\/p>\n
    Of course, the most obvious way is it protects the singleton with a lock.<\/p>\n
    <\/span>Lock<\/span><\/h2>\n
    The mutex wrapped in a lock<\/a> guarantees that the singleton will be thread-safe initialized.<\/p>\n
     <\/p>\n
    <\/p>\n
    \n\n\n\n
    \n
     1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45\r\n46\r\n47\r\n48\r\n49\r\n50\r\n51\r\n52\r\n53\r\n54<\/pre>\n<\/td>\n
    		\n
    \/\/ singletonLock.cpp<\/span>\r\n\r\n#include <chrono><\/span>\r\n#include <iostream><\/span>\r\n#include <future><\/span>\r\n#include <mutex><\/span>\r\n\r\nconstexpr auto<\/span> tenMill= 10000000;\r\n\r\nstd::mutex myMutex;\r\n\r\nclass<\/span> MySingleton<\/span>{\r\npublic:\r\n  static<\/span> MySingleton& getInstance(){\r\n    std::lock_guard<std::mutex> myLock(myMutex);\r\n    if<\/span> ( !instance ){\r\n        instance= new<\/span> MySingleton();\r\n    }\r\n    \/\/ volatile int dummy{};<\/span>\r\n    return<\/span> *instance;\r\n  }\r\nprivate:\r\n  MySingleton()= default<\/span>;\r\n  ~MySingleton()= default<\/span>;\r\n  MySingleton(const<\/span> MySingleton&)= delete<\/span>;\r\n  MySingleton& operator<\/span>=(const<\/span> MySingleton&)= delete<\/span>;\r\n\r\n  static<\/span> MySingleton* instance;\r\n};\r\n\r\n\r\nMySingleton* MySingleton::instance= nullptr;\r\n\r\nstd::chrono::duration<double<\/span>> getTime(){\r\n\r\n  auto<\/span> begin= std::chrono::system_clock::now();\r\n  for<\/span> ( size_t<\/span> i= 0; i <= tenMill; ++i){\r\n       MySingleton::getInstance();\r\n  }\r\n  return<\/span> std::chrono::system_clock::now() - begin;\r\n  \r\n};\r\n\r\nint<\/span> main(){\r\n  \r\n    auto<\/span> fut1= std::async(std::launch::async,getTime);\r\n    auto<\/span> fut2= std::async(std::launch::async,getTime);\r\n    auto<\/span> fut3= std::async(std::launch::async,getTime);\r\n    auto<\/span> fut4= std::async(std::launch::async,getTime);\r\n    \r\n    auto<\/span> total= fut1.get() + fut2.get() + fut3.get() + fut4.get();\r\n    \r\n    std::cout << total.count() << std::endl;\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
     <\/p>\n
    How fast is the classical thread-safe implementation of the singleton pattern?<\/p>\n
    Without optimization<\/h4>\n
     \"singletonLock\"\"singletonLock<\/p>\n
    Maximum optimization<\/h4>\n
    \"singletonLock\"singletonLock<\/p>\n
    Not so fast. Atomics should make a difference.<\/p>\n
    <\/span>Atomic variables<\/span><\/h2>\n
    With atomic variables, my job becomes exceptionally challenging. Now I have to use the C++ memory model<\/a>. I base my implementation on the well-known double-checked locking pattern.<\/a><\/p>\n
    <\/span>Sequential consistency<\/span><\/h3>\n
    The handle to the singleton is atomic. Because I didn’t specify the C++ memory model, the default applies Sequential consistency. <\/a><\/p>\n
     <\/p>\n
    <\/p>\n
    \n\n\n\n
    \n
     1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45\r\n46\r\n47\r\n48\r\n49\r\n50\r\n51\r\n52\r\n53\r\n54\r\n55\r\n56\r\n57\r\n58\r\n59\r\n60\r\n61\r\n62<\/pre>\n<\/td>\n
    		\n
    \/\/ singletonAcquireRelease.cpp<\/span>\r\n\r\n#include <atomic><\/span>\r\n#include <iostream><\/span>\r\n#include <future><\/span>\r\n#include <mutex><\/span>\r\n#include <thread><\/span>\r\n\r\nconstexpr auto<\/span> tenMill= 10000000;\r\n\r\nclass<\/span> MySingleton<\/span>{\r\npublic:\r\n  static<\/span> MySingleton* getInstance(){\r\n    MySingleton* sin= instance.load();\r\n    if<\/span> ( !sin ){\r\n      std::lock_guard<std::mutex> myLock(myMutex);\r\n      sin= instance.load();\r\n      if<\/span>( !sin ){\r\n        sin= new<\/span> MySingleton();\r\n        instance.store(sin);\r\n      }\r\n    }   \r\n    \/\/ volatile int dummy{};<\/span>\r\n    return<\/span> sin;\r\n  }\r\nprivate:\r\n  MySingleton()= default<\/span>;\r\n  ~MySingleton()= default<\/span>;\r\n  MySingleton(const<\/span> MySingleton&)= delete<\/span>;\r\n  MySingleton& operator<\/span>=(const<\/span> MySingleton&)= delete<\/span>;\r\n\r\n  static<\/span> std::atomic<MySingleton*> instance;\r\n  static<\/span> std::mutex myMutex;\r\n};\r\n\r\n\r\nstd::atomic<MySingleton*> MySingleton::instance;\r\nstd::mutex MySingleton::myMutex;\r\n\r\nstd::chrono::duration<double<\/span>> getTime(){\r\n\r\n  auto<\/span> begin= std::chrono::system_clock::now();\r\n  for<\/span> ( size_t<\/span> i= 0; i <= tenMill; ++i){\r\n       MySingleton::getInstance();\r\n  }\r\n  return<\/span> std::chrono::system_clock::now() - begin;\r\n  \r\n};\r\n\r\n\r\nint<\/span> main(){\r\n\r\n    auto<\/span> fut1= std::async(std::launch::async,getTime);\r\n    auto<\/span> fut2= std::async(std::launch::async,getTime);\r\n    auto<\/span> fut3= std::async(std::launch::async,getTime);\r\n    auto<\/span> fut4= std::async(std::launch::async,getTime);\r\n    \r\n    auto<\/span> total= fut1.get() + fut2.get() + fut3.get() + fut4.get();\r\n    \r\n    std::cout << total.count() << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
     <\/p>\n
    Now I’m curious.<\/p>\n
    Without optimization<\/h4>\n
     \"singletonSequentialConsistency\"\"singletonSequentialConsistency<\/p>\n
    Maximum optimization<\/h4>\n
    \"singletonSequentialConsistency\"singletonSequentialConsistency<\/p>\n
     <\/p>\n
    But we can do better. There is an additional optimization possibility.<\/p>\n
    <\/span>Acquire-release Semantic<\/span><\/h3>\n
    The reading of the singleton (line 14) is an acquire operation, and the writing is a release operation (line 20). Because both operations occur on the same atomic I don’t need sequential consistency. The C++ standard guarantees that an acquire operation synchronizes with a release operation on the same atomic. These conditions hold in this case. Therefore, I can weaken the C++ memory model in lines 14 and 20. Acquire-release semantic <\/a>is sufficient.<\/p>\n
    <\/p>\n
    \n\n\n\n
    \n
     1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45\r\n46\r\n47\r\n48\r\n49\r\n50\r\n51\r\n52\r\n53\r\n54\r\n55\r\n56\r\n57\r\n58\r\n59\r\n60\r\n61\r\n62<\/pre>\n<\/td>\n
    		\n
    \/\/ singletonAcquireRelease.cpp<\/span>\r\n\r\n#include <atomic><\/span>\r\n#include <iostream><\/span>\r\n#include <future><\/span>\r\n#include <mutex><\/span>\r\n#include <thread><\/span>\r\n\r\nconstexpr auto<\/span> tenMill= 10000000;\r\n\r\nclass<\/span> MySingleton<\/span>{\r\npublic:\r\n  static<\/span> MySingleton* getInstance(){\r\n    MySingleton* sin= instance.load(std::memory_order_acquire);\r\n    if<\/span> ( !sin ){\r\n      std::lock_guard<std::mutex> myLock(myMutex);\r\n      sin= instance.load(std::memory_order_relaxed);\r\n      if<\/span>( !sin ){\r\n        sin= new<\/span> MySingleton();\r\n        instance.store(sin,std::memory_order_release);\r\n      }\r\n    }   \r\n    \/\/ volatile int dummy{};<\/span>\r\n    return<\/span> sin;\r\n  }\r\nprivate:\r\n  MySingleton()= default<\/span>;\r\n  ~MySingleton()= default<\/span>;\r\n  MySingleton(const<\/span> MySingleton&)= delete<\/span>;\r\n  MySingleton& operator<\/span>=(const<\/span> MySingleton&)= delete<\/span>;\r\n\r\n  static<\/span> std::atomic<MySingleton*> instance;\r\n  static<\/span> std::mutex myMutex;\r\n};\r\n\r\n\r\nstd::atomic<MySingleton*> MySingleton::instance;\r\nstd::mutex MySingleton::myMutex;\r\n\r\nstd::chrono::duration<double<\/span>> getTime(){\r\n\r\n  auto<\/span> begin= std::chrono::system_clock::now();\r\n  for<\/span> ( size_t<\/span> i= 0; i <= tenMill; ++i){\r\n       MySingleton::getInstance();\r\n  }\r\n  return<\/span> std::chrono::system_clock::now() - begin;\r\n  \r\n};\r\n\r\n\r\nint<\/span> main(){\r\n\r\n    auto<\/span> fut1= std::async(std::launch::async,getTime);\r\n    auto<\/span> fut2= std::async(std::launch::async,getTime);\r\n    auto<\/span> fut3= std::async(std::launch::async,getTime);\r\n    auto<\/span> fut4= std::async(std::launch::async,getTime);\r\n    \r\n    auto<\/span> total= fut1.get() + fut2.get() + fut3.get() + fut4.get();\r\n    \r\n    std::cout << total.count() << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
     <\/p>\n
    The acquire-release semantic has a similar performance as the sequential consistency. That’s not surprising because on x86, both memory models are very similar. We would get different numbers on an ARMv7 or PowerPC architecture. You can read the details on Jeff Preshing’s blog Preshing on Programming<\/a>.<\/p>\n
    Without optimization<\/h4>\n
     \"singletonAcquireRelease\"\"singletonAcquireRelease<\/p>\n
    Maximum optimization<\/h4>\n
    \"singletonAcquireRelease\"singletonAcquireRelease.<\/p>\n
    If I forget an import variant of the thread-safe singleton pattern, please let me know and send me the code. I will measure it and add the numbers to the comparison.<\/p>\n
    <\/span>All numbers at one glance<\/span><\/h2>\n
    Don’t take the numbers too seriously. I executed each program only once, and the executable is optimized for four cores on my two-core windows PC. But the numbers give a clear indication. The Meyers Singleton is the easiest to get and the fastest one. In particular, the lock-based implementation is by far the slowest one. The numbers are independent of the used platform.<\/p>\n
    But the numbers show more. Optimization counts. This statement is not totally accurate for the std::lock_guard<\/span> based implementation of the singleton pattern.<\/p>\n
     <\/p>\n
    \"comparisonSingletonEng\"<\/p>\n
    <\/span>What’s next?<\/span><\/h2>\n
    I’m not so sure. This post is a translation of a german post I wrote half a year ago. My German post gets a lot of reaction. I’m not sure what will happen this time. A few days’ later, I’m sure. The next post<\/a> will be about adding the elements of a vector. First, it takes in one thread.<\/p>\n
     <\/p>\n
     <\/p>\n
     <\/p>\n
     <\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
    There are a lot of issues with the singleton pattern. I’m aware of that. But the singleton pattern is an ideal use case for a variable, which can only be initialized in a thread-safe way. From that point on, you can use it without synchronization. So in this post, I discuss different ways to initialize […]<\/p>\n","protected":false},"author":21,"featured_media":4858,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[369],"tags":[505,434,430,433,470,519,404,520],"class_list":["post-4885","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-multithreading-application","tag-acquire-release-semantic","tag-atomics","tag-lock","tag-mutex","tag-performance","tag-sequential-consistency","tag-singleton","tag-static"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4885","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=4885"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4885\/revisions"}],"predecessor-version":[{"id":6952,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4885\/revisions\/6952"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/4858"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=4885"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=4885"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=4885"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}