restructure

technology/dev/programming/patterns/creational/Singleton Pattern.md

@@ -0,0 +1,71 @@
+---
+obj: concept
+---
+# Singleton Pattern
+
+## **Description:**
+The Singleton Pattern is a creational design pattern that ensures a class has only one instance and provides a global point of access to that instance. It is commonly used when you want to restrict the instantiation of a class to a single object and control access to that unique instance across the application.
+
+**How it's Used:**
+1. **Private Constructor**: Ensure that the class has a private constructor to prevent direct instantiation from external code.
+2. **Static Instance**: Create a static instance of the class within the class itself.
+3. **Lazy or Eager Initialization**: Decide whether to initialize the instance lazily (on-demand) or eagerly (at the time of class loading). Lazy initialization is preferred if resource usage should be minimized.
+4. **Static Method**: Provide a static method within the class to access the unique instance. This method should handle the creation of the instance if it doesn't exist or return the existing instance.
+5. **Thread Safety (Optional)**: If your application is multithreaded, ensure that the creation of the instance and access to it is thread-safe, especially if using lazy initialization.
+
+## **Example:**
+A classic example of the Singleton Pattern is creating a configuration manager that provides access to application-wide configuration settings:
+
+```java
+public class ConfigurationManager {
+    private static ConfigurationManager instance; // Static instance variable
+    private String configurationData;
+
+    // Private constructor to prevent external instantiation
+    private ConfigurationManager() {
+        // Initialize configurationData from a configuration file or other source
+        configurationData = "Default configuration";
+    }
+
+    // Static method to provide access to the unique instance
+    public static ConfigurationManager getInstance() {
+        if (instance == null) {
+            instance = new ConfigurationManager(); // Lazy initialization
+        }
+        return instance;
+    }
+
+    public String getConfigurationData() {
+        return configurationData;
+    }
+
+    public void setConfigurationData(String data) {
+        configurationData = data;
+    }
+}
+```
+
+In this Java example:
+- The `ConfigurationManager` class has a private constructor to prevent external instantiation.
+- It contains a private static instance variable.
+- The `getInstance` static method is used to access the unique instance of the class. It initializes the instance lazily when called for the first time.
+- You can use `ConfigurationManager.getInstance()` to access the configuration manager from anywhere in your application.
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        ConfigurationManager configManager1 = ConfigurationManager.getInstance();
+        ConfigurationManager configManager2 = ConfigurationManager.getInstance();
+
+        // Both instances refer to the same unique object
+        System.out.println(configManager1 == configManager2); // true
+
+        // Access and modify configuration data
+        System.out.println(configManager1.getConfigurationData()); // Default configuration
+        configManager1.setConfigurationData("New configuration");
+        System.out.println(configManager2.getConfigurationData()); // New configuration
+    }
+}
+```
+
+The Singleton Pattern ensures that there's only one instance of `ConfigurationManager` throughout the application, providing a centralized and controlled way to manage configuration data.