Singleton Pattern

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

/**
 * Eager Initialization - Thread-safe by construction
 * 
 * The JVM guarantees that class initialization is thread-safe.
 * The instance is created when the class loads, before any thread
 * can access getInstance().
 */
public class EagerSingleton {
    // Static initializer runs when class is loaded - thread-safe
    private static final EagerSingleton INSTANCE = new EagerSingleton();
    
    private EagerSingleton() {
        System.out.println("EagerSingleton: Constructed");
        // Expensive initialization here...
    }
    
    // No synchronization needed - instance already exists
    public static EagerSingleton getInstance() {
        return INSTANCE;
    }
    
    public void operation() {
        System.out.println("EagerSingleton: Operation performed");
    }
}
 
/*
 * Thread Safety Analysis:
 * 
 * The JLS (Java Language Specification) guarantees that:
 * 1. Class initialization is performed while holding a lock
 * 2. The lock is released before any thread can see the initialized state
 * 3. Subsequent accesses see the fully constructed instance
 * 
 * Therefore, INSTANCE is guaranteed to be:
 * - Created exactly once
 * - Fully constructed before any thread reads it
 * - Never null when returned from getInstance()
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

/**
 * Synchronized Accessor - Thread-safe but slow
 * 
 * The synchronized keyword ensures only one thread can execute
 * getInstance() at a time, preventing race conditions.
 */
public class SynchronizedSingleton {
    private static SynchronizedSingleton instance;
    
    private SynchronizedSingleton() {
        System.out.println("SynchronizedSingleton: Constructed");
    }
    
    // synchronized = only one thread can be inside at any time
    public static synchronized SynchronizedSingleton getInstance() {
        if (instance == null) {
            instance = new SynchronizedSingleton();
        }
        return instance;
    }
    
    /*
     * Performance Analysis:
     * 
     * Call 1 (instance is null):
     *   - Thread A acquires lock
     *   - Thread B waits for lock
     *   - Thread A creates instance, releases lock
     *   - Thread B acquires lock, sees non-null, releases lock
     *   
     * Call 1000001 (instance exists):
     *   - STILL acquires lock (unnecessary!)
     *   - STILL does visibility synchronization (unnecessary!)
     *   - Thread contention on hot path
     * 
     * This pattern trades performance for simplicity.
     * For singletons accessed frequently, consider alternatives.
     */
}
 
// TypeScript equivalent using class-level lock
class SynchronizedSingletonTS {
    private static instance: SynchronizedSingletonTS | null = null;
    private static initializationLock = new Lock(); // Conceptual
    
    private constructor() {}
    
    public static async getInstance(): Promise<SynchronizedSingletonTS> {
        // In JS/TS single-threaded event loop, this is less critical
        // But for educational purposes, conceptual implementation:
        await SynchronizedSingletonTS.initializationLock.acquire();
        try {
            if (!SynchronizedSingletonTS.instance) {
                SynchronizedSingletonTS.instance = new SynchronizedSingletonTS();
            }
            return SynchronizedSingletonTS.instance;
        } finally {
            SynchronizedSingletonTS.initializationLock.release();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

/**
 * Double-Checked Locking - Correct implementation (Java 5+)
 * 
 * CRITICAL: The volatile keyword is REQUIRED for correctness.
 * Without it, a thread might see a non-null reference to a
 * partially constructed object.
 */
public class DoubleCheckedLockingSingleton {
    // MUST be volatile! See explanation below.
    private static volatile DoubleCheckedLockingSingleton instance;
    
    private DoubleCheckedLockingSingleton() {
        System.out.println("DCL Singleton: Constructed");
    }
    
    public static DoubleCheckedLockingSingleton getInstance() {
        // First check (no lock) - fast path for common case
        if (instance == null) {
            // Lock only if instance might need creation
            synchronized (DoubleCheckedLockingSingleton.class) {
                // Second check (with lock) - ensure another thread didn't create
                if (instance == null) {
                    instance = new DoubleCheckedLockingSingleton();
                }
            }
        }
        return instance;
    }
    
    /*
     * Why volatile is required:
     * 
     * Without volatile, the JVM/CPU can reorder operations:
     * 
     * Normal expectation:
     *   1. Allocate memory for object
     *   2. Initialize object (run constructor)
     *   3. Assign reference to 'instance' variable
     * 
     * What might actually happen without volatile:
     *   1. Allocate memory for object
     *   2. Assign reference to 'instance' variable (non-null now!)
     *   3. Initialize object (constructor not yet complete!)
     * 
     * Thread B calls getInstance():
     *   - Sees instance != null (first check passes)
     *   - Returns instance to caller
     *   - Caller uses PARTIALLY CONSTRUCTED object!
     *   - Undefined behavior, crashes, data corruption
     * 
     * The volatile keyword prevents this reordering by establishing
     * a "happens-before" relationship: all operations before the
     * volatile write are visible to any thread that reads the volatile.
     */
}
 
// Correct TypeScript implementation (with lock abstraction)
class DoubleCheckedSingleton {
    private static instance: DoubleCheckedSingleton | null = null;
    private static readonly lock = new Object(); // Conceptual lock
    
    private constructor() {
        console.log("DCL Singleton: Constructed");
    }
    
    public static getInstance(): DoubleCheckedSingleton {
        // In JavaScript/TypeScript, the single-threaded event loop
        // means true DCL isn't needed, but for completeness:
        
        // First check - fast path
        if (DoubleCheckedSingleton.instance === null) {
            // In a multi-threaded context, you'd lock here
            // Second check after (hypothetical) lock
            if (DoubleCheckedSingleton.instance === null) {
                DoubleCheckedSingleton.instance = new DoubleCheckedSingleton();
            }
        }
        return DoubleCheckedSingleton.instance;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

/**
 * Bill Pugh Singleton - The Holder/IODH Idiom
 * 
 * Uses a nested static class to defer initialization until first use.
 * The JVM's class loading mechanism provides thread safety for free.
 */
public class HolderSingleton {
    
    // Private constructor
    private HolderSingleton() {
        System.out.println("HolderSingleton: Constructed");
    }
    
    /**
     * Static nested holder class.
     * This class is NOT loaded when HolderSingleton loads.
     * It loads only when getInstance() references it.
     */
    private static class SingletonHolder {
        // Class loading is synchronized by JVM
        private static final HolderSingleton INSTANCE = new HolderSingleton();
    }
    
    /**
     * First call to getInstance() causes SingletonHolder to load.
     * JVM handles synchronization during class initialization.
     * Subsequent calls just return the already-created instance.
     * No explicit synchronization needed in user code!
     */
    public static HolderSingleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
    
    public void operation() {
        System.out.println("HolderSingleton: Operation performed");
    }
}
 
/*
 * Execution Timeline:
 * 
 * T0: Application starts
 * T1: HolderSingleton class loads (constructor NOT called)
 * T2: Some code, no Singleton usage yet...
 * 
 * T3: First call to HolderSingleton.getInstance()
 *     - JVM sees reference to SingletonHolder.INSTANCE
 *     - SingletonHolder class needs to load
 *     - JVM acquires class loading lock
 *     - SingletonHolder.<clinit> runs, creating INSTANCE
 *     - JVM releases lock
 *     - getInstance() returns INSTANCE
 * 
 * T4: Second call to HolderSingleton.getInstance()
 *     - SingletonHolder already loaded
 *     - Just return INSTANCE (no lock!)
 * 
 * T5-T1000000: All subsequent calls are lock-free field access
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

/**
 * Enum Singleton - The Joshua Bloch recommended approach
 * 
 * Provides thread safety, serialization safety, and reflection safety
 * all in one simple declaration.
 */
public enum ConfigurationManager {
    // This IS the singleton instance
    INSTANCE;
    
    // Instance fields (initialized in constructor)
    private final Map<String, String> settings;
    private final Instant loadedAt;
    
    // Enum constructor - runs exactly once when INSTANCE initializes
    ConfigurationManager() {
        System.out.println("ConfigurationManager: Initializing");
        this.settings = new HashMap<>();
        this.loadedAt = Instant.now();
        loadSettings();
    }
    
    private void loadSettings() {
        settings.put("app.name", "MyApplication");
        settings.put("app.version", "1.0.0");
        settings.put("database.host", System.getenv("DB_HOST"));
    }
    
    // Public methods (no need for getInstance - just use INSTANCE)
    public String get(String key) {
        return settings.get(key);
    }
    
    public Instant getLoadedAt() {
        return loadedAt;
    }
}
 
// Usage:
// String appName = ConfigurationManager.INSTANCE.get("app.name");
 
/*
 * Why enum is bulletproof:
 * 
 * 1. THREAD SAFETY
 *    - Enum values are class constants initialized during class loading
 *    - JVM synchronizes class loading
 *    - Guaranteed single instance
 * 
 * 2. SERIALIZATION SAFETY
 *    - Enums have special serialization rules in Java
 *    - Serialization only stores the enum name
 *    - Deserialization looks up by name, returning the existing instance
 *    - No readResolve() needed
 * 
 * 3. REFLECTION SAFETY
 *    - The Constructor.newInstance() method explicitly checks for enums
 *    - Throws IllegalArgumentException if you try to reflectively 
 *      create an enum instance
 *    - Cannot be bypassed
 * 
 * 4. SIMPLICITY
 *    - Literally one line to declare the singleton
 *    - No accessors, locks, volatile, holder classes needed
 */
 
// Demonstration of reflection safety:
public class EnumReflectionDemo {
    public static void main(String[] args) {
        try {
            Constructor<ConfigurationManager> constructor = 
                ConfigurationManager.class.getDeclaredConstructor();
            constructor.setAccessible(true);
            constructor.newInstance(); // THROWS EXCEPTION
        } catch (Exception e) {
            System.out.println("Cannot reflectively create enum: " + e);
            // Output: Cannot reflectively create enum: 
            // java.lang.IllegalArgumentException: Cannot reflectively 
            // create enum objects
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public sealed class ConfigurationManager
{
    // Lazy<T> provides thread-safe lazy initialization out of the box
    private static readonly Lazy<ConfigurationManager> _lazy = 
        new Lazy<ConfigurationManager>(() => new ConfigurationManager());
    
    public static ConfigurationManager Instance => _lazy.Value;
    
    private readonly Dictionary<string, string> _settings;
    
    private ConfigurationManager()
    {
        Console.WriteLine("ConfigurationManager: Initializing");
        _settings = new Dictionary<string, string>
        {
            ["app.name"] = "MyApplication",
            ["app.version"] = "1.0.0"
        };
    }
    
    public string? Get(string key) => 
        _settings.TryGetValue(key, out var value) ? value : null;
}
 
// Usage: var name = ConfigurationManager.Instance.Get("app.name");
 
/*
 * Lazy<T> options:
 * - LazyThreadSafetyMode.ExecutionAndPublication (default) - one thread creates
 * - LazyThreadSafetyMode.PublicationOnly - multiple may create, one is kept
 * - LazyThreadSafetyMode.None - not thread-safe
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

use once_cell::sync::Lazy;
use std::collections::HashMap;
 
// Lazy static using once_cell - thread-safe by design
static CONFIG: Lazy<ConfigurationManager> = Lazy::new(|| {
    println!("ConfigurationManager: Initializing");
    ConfigurationManager::new()
});
 
pub struct ConfigurationManager {
    settings: HashMap<String, String>,
}
 
impl ConfigurationManager {
    fn new() -> Self {
        let mut settings = HashMap::new();
        settings.insert("app.name".to_string(), "MyApplication".to_string());
        settings.insert("app.version".to_string(), "1.0.0".to_string());
        ConfigurationManager { settings }
    }
    
    pub fn get(&self, key: &str) -> Option<&String> {
        self.settings.get(key)
    }
}
 
// Usage:
fn main() {
    // First access initializes the singleton
    let name = CONFIG.get("app.name");
    println!("App name: {:?}", name);
    
    // Rust's ownership system ensures thread safety
    // once_cell::sync::Lazy uses std::sync::Once internally
}
 
// Alternative using std::sync::OnceLock (stable since Rust 1.70):
/*
use std::sync::OnceLock;
 
static CONFIG: OnceLock<ConfigurationManager> = OnceLock::new();
 
fn get_config() -> &'static ConfigurationManager {
    CONFIG.get_or_init(|| ConfigurationManager::new())
}
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

# Python: Modules are singletons by default
# This is the most Pythonic approach
 
# configuration.py
import os
from typing import Optional
 
class _ConfigurationManager:
    """Internal implementation - not exported directly."""
    
    def __init__(self):
        print("ConfigurationManager: Initializing")
        self._settings = {
            "app.name": "MyApplication",
            "app.version": "1.0.0",
            "database.host": os.environ.get("DB_HOST", "localhost"),
        }
    
    def get(self, key: str) -> Optional[str]:
        return self._settings.get(key)
 
# Module-level singleton instance
# Python's import system ensures this runs exactly once
_instance = _ConfigurationManager()
 
# Public function to access singleton
def get_configuration() -> _ConfigurationManager:
    return _instance
 
# Alternative: Direct access through module
# from configuration import _instance as config
# name = config.get("app.name")
 
# For thread-safe lazy initialization if needed:
import threading
 
class ThreadSafeSingleton:
    _instance: Optional['ThreadSafeSingleton'] = None
    _lock = threading.Lock()
    
    def __new__(cls):
        if cls._instance is None:
            with cls._lock:  # Double-checked locking
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
                    cls._instance._initialize()
        return cls._instance
    
    def _initialize(self):
        self._settings = {"app.name": "MyApplication"}