Use std::call_once instead of double-checked locking in singletons

include/cpr/singleton.h

@@ -1,6 +1,7 @@
 #ifndef CPR_SINGLETON_H
 #define CPR_SINGLETON_H
 
+#include <cassert>
 #include <mutex>
 
 #ifndef CPR_DISABLE_COPY
@@ -10,38 +11,33 @@
 #endif
 
 #ifndef CPR_SINGLETON_DECL
-#define CPR_SINGLETON_DECL(Class) \
-  public:                         \
-    static Class* GetInstance();  \
-    static void ExitInstance();   \
-                                  \
-  private:                        \
-    CPR_DISABLE_COPY(Class)       \
-    static Class* s_pInstance;    \
-    static std::mutex s_mutex;
+#define CPR_SINGLETON_DECL(Class)    \
+  public:                            \
+    static Class* GetInstance();     \
+    static void ExitInstance();      \
+                                     \
+  private:                           \
+    CPR_DISABLE_COPY(Class)          \
+    static Class* s_pInstance;       \
+    static std::once_flag s_getFlag; \
+    static std::once_flag s_exitFlag;
 #endif
 
 #ifndef CPR_SINGLETON_IMPL
-#define CPR_SINGLETON_IMPL(Class)         \
-    Class* Class::s_pInstance = nullptr;  \
-    std::mutex Class::s_mutex;            \
-    Class* Class::GetInstance() {         \
-        if (s_pInstance == nullptr) {     \
-            s_mutex.lock();               \
-            if (s_pInstance == nullptr) { \
-                s_pInstance = new Class;  \
-            }                             \
-            s_mutex.unlock();             \
-        }                                 \
-        return s_pInstance;               \
-    }                                     \
-    void Class::ExitInstance() {          \
-        s_mutex.lock();                   \
-        if (s_pInstance) {                \
-            delete s_pInstance;           \
-            s_pInstance = nullptr;        \
-        }                                 \
-        s_mutex.unlock();                 \
+#define CPR_SINGLETON_IMPL(Class)                                            \
+    Class* Class::s_pInstance = nullptr;                                     \
+    std::once_flag Class::s_getFlag{};                                       \
+    std::once_flag Class::s_exitFlag{};                                      \
+    Class* Class::GetInstance() {                                            \
+        std::call_once(Class::s_getFlag, []() { s_pInstance = new Class; }); \
+        return s_pInstance;                                                  \
+    }                                                                        \
+    void Class::ExitInstance() {                                             \
+        std::call_once(Class::s_exitFlag, []() {                             \
+            assert(s_pInstance);                                             \
+            delete s_pInstance;                                              \
+            s_pInstance = nullptr;                                           \
+        });                                                                  \
     }
 #endif
 

test/CMakeLists.txt

@@ -64,6 +64,7 @@ add_cpr_test(interceptor_multi)
 add_cpr_test(multiperform)
 add_cpr_test(resolve)
 add_cpr_test(multiasync)
+add_cpr_test(singleton)
 add_cpr_test(threadpool)
 
 if (ENABLE_SSL_TESTS)

test/singleton_tests.cpp

@@ -0,0 +1,23 @@
+#include <gtest/gtest.h>
+
+#include "singleton_tests.hpp"
+
+// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+CPR_SINGLETON_IMPL(TestSingleton)
+
+TEST(SingletonTests, GetInstanceTest) {
+    const TestSingleton* singleton = TestSingleton::GetInstance();
+    EXPECT_NE(singleton, nullptr);
+}
+
+TEST(SingletonTests, ExitInstanceTest) {
+    TestSingleton* singleton = TestSingleton::GetInstance();
+    TestSingleton::ExitInstance();
+    singleton = TestSingleton::GetInstance();
+    EXPECT_EQ(singleton, nullptr);
+}
+
+int main(int argc, char** argv) {
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}

test/singleton_tests.hpp

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "cpr/cpr.h"
+
+class TestSingleton {
+    CPR_SINGLETON_DECL(TestSingleton)
+  private:
+    TestSingleton() = default;
+};