Small rework

Author: tomoss

singleton-cherno-example/inc/singleton.h

@@ -8,6 +8,7 @@ class Singleton {
     static Singleton& getInstance();
     static void delInstance();
     void func();
+
 private:
     Singleton();
     ~Singleton();

singleton-cherno-example/main.cpp

@@ -2,7 +2,7 @@
 #include "singleton.h"
 
 /*
-* Cherno example with static pointer 'global' variable
+* Example from Cherno with STATIC GLOBAL VARIABLE
 * Dynamic memory allocation
 * Lazy initialization
 * Singleton is created only after first call of getInstance() and destroyed by calling delInstance()

singleton-classic-dynamic-example/main.cpp

@@ -2,7 +2,7 @@
 #include "singleton.h"
 
 /*
-* Example with static pointer member variable
+* Example with STATIC MEMBER VARIABLE
 * Dynamic memory allocation
 * Lazy initialization
 * Singleton is created only after first call of getInstance() and destroyed by calling delInstance()

singleton-classic-static-example/inc/singleton.h

@@ -12,9 +12,9 @@ class Singleton
     }
 
     void func();
-    ~Singleton();
 
 private:
     Singleton();
+    ~Singleton();
     static Singleton instance; /* Declared static instance as member variable. */
 };

singleton-classic-static-example/main.cpp

@@ -2,7 +2,7 @@
 #include "singleton.h"
 
 /*
-* Example with static member variable
+* Example with STATIC MEMBER VARIABLE
 * Static memory allocation
 * Eager initialization
 * Singleton is created before main() and destroyed after main() call

singleton-dclp-example/inc/singleton.h

@@ -11,6 +11,7 @@ class Singleton {
     static void delInstance();
 
     void func();
+
 private:
     Singleton();
     ~Singleton();

singleton-dclp-example/main.cpp

@@ -1,38 +1,36 @@
 #include <iostream>
-#include <future>
+#include <thread>
+#include <vector>
 #include "singleton.h"
 
 /*
-* Singleton with Double-Checked Locking - static pointer member variable
+* Example with DOUBLE-CHECKED LOCKING PATTERN (DCLP)
 * Dynamic memory allocation
 * Lazy initialization
 * Singleton is created only after first call of getInstance() and destroyed by calling delInstance()
 * DCLP is designed to add efficient thread-safety to initialization of a shared resource (such as a Singleton), but it has a problem: it’s not reliable
-* DCLP can fail for different reasons
-* https://www.aristeia.com/Papers/DDJ_Jul_Aug_2004_revised.pdf
-* Multiple threads can read instance concurrently, and since instance is a raw pointer with no memory ordering guarantees, 
-* this is a data race and triggers undefined behavior in C++.
-* A pattern (Double-Checked Locking) that was obsoleted by C++11.
+* DCLP can fail for different reasons: Multiple threads can read instance concurrently, 
+* and since instance is a raw pointer with no memory ordering guarantees, this is a data race and triggers undefined behavior in C++.
+* This pattern (Double-Checked Locking) was obsoleted by C++11.
+* https://www.aristeia.com/Papers/DDJ_Jul_Aug_2004
 */
 
 int main()
 {
     std::cout << "--- main start ---" << std::endl;
 
-    Singleton::getInstance().func();
-
-    auto async1 = std::async(std::launch::async, []() {
-            Singleton::getInstance().func();
-    });
-
-    auto async2 = std::async(std::launch::async, []() {
+    std::vector<std::thread> threads;
+    
+    // Launch 10 threads
+    for (int i = 0; i < 10; ++i) {
+        threads.emplace_back([]() {
             Singleton::getInstance().func();
-    });
-
-    async1.wait();
-    async2.wait();
-
-    Singleton::delInstance();
+        });
+    }
+    
+    for (auto& t : threads) {
+        t.join();
+    }
 
     std::cout << "--- main end ---" << std::endl;
 }

singleton-meyers-example/inc/singleton.h

@@ -11,8 +11,8 @@ class Singleton {
     }
 
     void func();
-    ~Singleton();
 
 private:
     Singleton();
+    ~Singleton();
 };

singleton-meyers-example/main.cpp

@@ -1,19 +1,34 @@
 #include <iostream>
+#include <thread>
+#include <vector>
 #include "singleton.h"
 
 /*
-* Meyer’s Singleton - Example with static local variable
+* Meyer’s Singleton - Example with STATIC LOCAL VARIABLE
 * Static memory allocation
 * Lazy initialization
 * Singleton is created only after first call of getInstance() and destroyed after main() call
-* Thread-safe - Thread safety is guaranteed since C++11. A function-local static variable is initialized exactly once, even in a multi-threaded environment.
+* Thread-safe - Thread safety is guaranteed since C++11. 
+* A function-local static variable is initialized exactly once, even in a multi-threaded environment.
+* This is the best and simplest way to implement a singleton in C++11 and later.
 */
 
 int main()
 {
-	std::cout << "--- main start ---" << std::endl;
+    std::cout << "--- main start ---" << std::endl;
 
-	Singleton::getInstance().func();
+    std::vector<std::thread> threads;
+    
+    // Launch 10 threads
+    for (int i = 0; i < 10; ++i) {
+        threads.emplace_back([]() {
+            Singleton::getInstance().func();
+        });
+    }
+    
+    for (auto& t : threads) {
+        t.join();
+    }
 
-	std::cout << "--- main end ---" << std::endl;
+    std::cout << "--- main end ---" << std::endl;
 }

singleton-smart-pointer-example/main.cpp

@@ -1,10 +1,10 @@
-#include "singleton.h"
 #include <iostream>
 #include <vector>
 #include <thread>
+#include "singleton.h"
 
 /*
-* Singleton with local static unique pointer
+* Example with STATIC LOCAL VARIABLE that is a SMART POINTER
 * Dynamic memory allocation
 * Lazy initialization
 * Singleton is created in the first call of getInstance() and destroyed automatically after main() call