Safe Implementation Strategies

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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

/**
 * Production-Ready Double-Checked Locking in Java
 * 
 * Requirements:
 * - Java 5.0 or later (JSR-133 memory model)
 * - volatile keyword on instance field (ESSENTIAL)
 * - Local variable optimization (optional but recommended)
 */
public class DatabaseConnectionManager {
    
    // ═══════════════════════════════════════════════════════════════
    // CRITICAL: volatile keyword provides happens-before guarantee
    // ═══════════════════════════════════════════════════════════════
    private static volatile DatabaseConnectionManager instance = null;
    
    // Instance fields
    private final ConnectionPool pool;
    private final Configuration config;
    
    /**
     * Private constructor - prevents external instantiation
     */
    private DatabaseConnectionManager() {
        // Expensive initialization
        this.config = loadConfiguration();
        this.pool = new ConnectionPool(config.getPoolSize());
        pool.initialize();
        
        System.out.println("DatabaseConnectionManager initialized");
    }
    
    private Configuration loadConfiguration() {
        // Simulate loading from external source
        return new Configuration();
    }
    
    /**
     * Thread-safe lazy getter using Double-Checked Locking
     * 
     * Performance characteristics:
     * - First call: Synchronized (slow, happens once)
     * - Subsequent calls: Single volatile read (fast)
     */
    public static DatabaseConnectionManager getInstance() {
        // ═══════════════════════════════════════════════════════════
        // OPTIMIZATION: Local variable avoids multiple volatile reads
        // ═══════════════════════════════════════════════════════════
        DatabaseConnectionManager localRef = instance;
        
        // First check: No synchronization
        // Volatile read provides visibility guarantee
        if (localRef == null) {
            
            // Only synchronize when instance might need creation
            synchronized (DatabaseConnectionManager.class) {
                
                // Read again inside synchronized block
                localRef = instance;
                
                // Second check: Another thread may have initialized
                if (localRef == null) {
                    
                    // Create and assign
                    // The volatile write ensures all constructor
                    // writes are visible before the reference becomes visible
                    instance = localRef = new DatabaseConnectionManager();
                }
            }
        }
        
        return localRef;
    }
    
    /**
     * Public methods to use the singleton
     */
    public Connection getConnection() throws SQLException {
        return pool.borrowConnection();
    }
    
    public void releaseConnection(Connection conn) {
        pool.returnConnection(conn);
    }
}
 
/**
 * Usage example
 */
public class Application {
    public static void main(String[] args) {
        // First call - initializes the singleton
        DatabaseConnectionManager manager1 = 
            DatabaseConnectionManager.getInstance();
        
        // Subsequent calls - returns cached instance
        DatabaseConnectionManager manager2 = 
            DatabaseConnectionManager.getInstance();
        
        assert manager1 == manager2;  // Same instance
        
        // Use the singleton
        try {
            Connection conn = manager1.getConnection();
            // ... use connection ...
            manager1.releaseConnection(conn);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

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

/**
 * Initialization-on-Demand Holder Idiom
 * 
 * This is often PREFERRED over DCL in Java because:
 * - Simpler code (no volatile, no synchronized)
 * - Equally performant (no synchronization on fast path)
 * - Relies on JVM guarantees (less room for error)
 * - Works in all Java versions (not just 5+)
 */
public class ConfigurationManager {
    
    // Private constructor
    private ConfigurationManager() {
        System.out.println("ConfigurationManager initialized");
        // Expensive initialization here
    }
    
    /**
     * Inner static class - JVM guarantees:
     * 1. Not loaded until first reference
     * 2. Loaded exactly once
     * 3. Initialization is thread-safe
     */
    private static class Holder {
        // Static initializer runs when Holder class is loaded
        // JVM guarantees this happens exactly once, thread-safely
        private static final ConfigurationManager INSTANCE = 
            new ConfigurationManager();
    }
    
    /**
     * Thread-safe lazy getter
     * 
     * First call: Triggers loading of Holder class, which
     *             initializes INSTANCE
     * Subsequent calls: Returns already-initialized INSTANCE
     * 
     * No volatile reads, no lock acquisition - just return a constant
     */
    public static ConfigurationManager getInstance() {
        return Holder.INSTANCE;
    }
    
    // Public methods
    public String getProperty(String key) {
        // ...
        return null;
    }
}
 
/**
 * Why this works (JVM Specification):
 * 
 * Section 12.4.2 - "Class Initialization":
 * "The implementation of the Java Virtual Machine is responsible
 * for taking care of synchronization and recursive initialization
 * by using the following procedure..."
 * 
 * The JVM holds an initialization lock while initializing a class.
 * Other threads attempting to use the class block until 
 * initialization completes. This is exactly what we need!
 * 
 * Benefits over DCL:
 * - No volatile (simpler, no overhead)
 * - No synchronized (no lock overhead)
 * - No room for implementation error (fewer moving parts)
 * - Works in Java 1.1+ (not dependent on fixed memory model)
 */

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

/**
 * Enum Singleton - "The Right Way" per Joshua Bloch
 * 
 * Advantages:
 * - Thread-safe by JVM guarantee
 * - Serialization handled correctly (no duplicates)
 * - Reflection attacks prevented (can't create new enum instances)
 * - Most concise syntax
 */
public enum CacheManager {
    // The singleton instance - created when enum class is loaded
    INSTANCE;
    
    // Instance fields (initialized in constructor)
    private final Map<String, Object> cache;
    private final int maxSize;
    
    // Constructor (implicitly private for enums)
    CacheManager() {
        System.out.println("CacheManager initialized");
        this.maxSize = 10000;
        this.cache = new ConcurrentHashMap<>(maxSize);
    }
    
    // Public methods
    public void put(String key, Object value) {
        if (cache.size() < maxSize) {
            cache.put(key, value);
        }
    }
    
    public Object get(String key) {
        return cache.get(key);
    }
    
    public void clear() {
        cache.clear();
    }
}
 
/**
 * Usage
 */
public class Application {
    public static void main(String[] args) {
        // Access the singleton
        CacheManager.INSTANCE.put("user:123", new User("Alice"));
        Object user = CacheManager.INSTANCE.get("user:123");
        
        // All of these refer to the same instance:
        CacheManager c1 = CacheManager.INSTANCE;
        CacheManager c2 = CacheManager.INSTANCE;
        assert c1 == c2;  // Always true
    }
}
 
/**
 * Why enum singletons are special:
 * 
 * 1. Thread Safety
 *    - JVM initializes enum values during class loading
 *    - This is inherently thread-safe (like Holder idiom)
 * 
 * 2. Serialization
 *    - Enum serialization is handled specially by Java
 *    - Deserializing always returns the existing INSTANCE
 *    - No duplicate singletons from serialization attacks
 * 
 * 3. Reflection Protection
 *    - Java explicitly prohibits creating new enum instances via reflection
 *    - Enum.class.newInstance() throws IllegalArgumentException
 * 
 * 4. Lazy Loading (with a catch)
 *    - Enum is loaded when any of its values are first accessed
 *    - But if you have multiple enum values, ALL are initialized
 *    - For single-instance enums like INSTANCE, this is effectively lazy
 */

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

/**
 * Double-Checked Locking in C#
 * 
 * Uses volatile for the instance reference
 * Note: C# volatile has slightly different semantics than Java
 */
public sealed class DatabaseManager {
    // volatile is REQUIRED for correct DCL
    private static volatile DatabaseManager _instance;
    private static readonly object _lock = new object();
    
    private readonly string _connectionString;
    
    private DatabaseManager() {
        Console.WriteLine("DatabaseManager initialized");
        _connectionString = LoadConnectionString();
    }
    
    private string LoadConnectionString() => 
        "Server=localhost;Database=MyApp;";
    
    public static DatabaseManager Instance {
        get {
            // First check (volatile read)
            if (_instance == null) {
                lock (_lock) {
                    // Second check
                    if (_instance == null) {
                        _instance = new DatabaseManager();
                    }
                }
            }
            return _instance;
        }
    }
    
    public string GetConnection() => _connectionString;
}

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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

"""
Thread-Safe Singleton Implementations in Python
"""
import threading
from functools import lru_cache
from typing import Optional
 
 
class SingletonMeta(type):
    """
    Thread-safe singleton metaclass using DCL pattern.
    
    Classes using this metaclass will be singletons.
    """
    _instances: dict = {}
    _lock: threading.Lock = threading.Lock()
    
    def __call__(cls, *args, **kwargs):
        # First check (outside lock)
        if cls not in cls._instances:
            with cls._lock:
                # Second check (inside lock)
                if cls not in cls._instances:
                    instance = super().__call__(*args, **kwargs)
                    cls._instances[cls] = instance
        return cls._instances[cls]
 
 
class DatabasePool(metaclass=SingletonMeta):
    """Example singleton using the metaclass"""
    
    def __init__(self):
        print("DatabasePool initialized")
        self.connections = []
        self._setup_pool()
    
    def _setup_pool(self):
        # Create initial connections
        for i in range(10):
            self.connections.append(f"connection_{i}")
    
    def get_connection(self):
        return self.connections[0] if self.connections else None
 
 
# ═══════════════════════════════════════════════════════════════
# Alternative: Module-level singleton (Python's natural approach)
# ═══════════════════════════════════════════════════════════════
 
class _ConfigManager:
    """Private implementation class"""
    def __init__(self):
        print("ConfigManager initialized")
        self.settings = {}
        self._load_config()
    
    def _load_config(self):
        self.settings = {"debug": True, "log_level": "INFO"}
    
    def get(self, key: str):
        return self.settings.get(key)
 
 
# Module-level instance - Python imports are cached
# First import initializes; subsequent imports return cached module
config_manager = _ConfigManager()
 
 
# ═══════════════════════════════════════════════════════════════
# Alternative: Decorator approach
# ═══════════════════════════════════════════════════════════════
 
def singleton(cls):
    """
    Decorator to make a class a thread-safe singleton.
    """
    instances = {}
    lock = threading.Lock()
    
    def get_instance(*args, **kwargs):
        if cls not in instances:
            with lock:
                if cls not in instances:
                    instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    
    return get_instance
 
 
@singleton
class EventBus:
    """Example singleton using decorator"""
    
    def __init__(self):
        print("EventBus initialized")
        self.subscribers = []
    
    def subscribe(self, handler):
        self.subscribers.append(handler)
    
    def publish(self, event):
        for handler in self.subscribers:
            handler(event)
 
 
# Usage
if __name__ == "__main__":
    # All of these return the same instance
    pool1 = DatabasePool()
    pool2 = DatabasePool()
    print(f"Same pool: {pool1 is pool2}")  # True
    
    bus1 = EventBus()
    bus2 = EventBus()
    print(f"Same bus: {bus1 is bus2}")  # True