Double-Checked Locking 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
40
41
42
43
44
45
46
47
48
49
50

/**
 * Single-Threaded Lazy Initialization
 * Works perfectly in single-threaded contexts
 */
class ExpensiveResource {
    private static instance: ExpensiveResource | null = null;
    
    // Private constructor prevents direct instantiation
    private constructor() {
        // Simulate expensive initialization
        console.log("Creating expensive resource...");
        this.loadConfigFromDisk();
        this.establishDatabaseConnections();
        this.warmUpCaches();
    }
    
    private loadConfigFromDisk(): void {
        // Simulate 500ms disk I/O
    }
    
    private establishDatabaseConnections(): void {
        // Simulate 1000ms connection setup
    }
    
    private warmUpCaches(): void {
        // Simulate 2000ms cache population
    }
    
    /**
     * Lazy getter - creates instance on first call
     * In single-threaded code, this is completely safe
     */
    public static getInstance(): ExpensiveResource {
        if (ExpensiveResource.instance === null) {
            // First call: create the instance
            ExpensiveResource.instance = new ExpensiveResource();
        }
        // Subsequent calls: return cached instance
        return ExpensiveResource.instance;
    }
    
    public doWork(): void {
        console.log("Performing work with expensive resource");
    }
}
 
// Usage
const resource = ExpensiveResource.getInstance(); // First call: initializes
const sameResource = ExpensiveResource.getInstance(); // Returns cached
console.log(resource === sameResource); // true

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

/**
 * DANGEROUS: Race condition in lazy initialization
 * This code is broken when called from multiple threads
 */
class DatabaseConnectionPool {
    private static instance: DatabaseConnectionPool | null = null;
    private static creationCount = 0;
    
    private connections: Connection[] = [];
    private instanceId: number;
    
    private constructor() {
        DatabaseConnectionPool.creationCount++;
        this.instanceId = DatabaseConnectionPool.creationCount;
        
        console.log(`Creating connection pool #${this.instanceId}...`);
        
        // Expensive: create 10 database connections
        for (let i = 0; i < 10; i++) {
            this.connections.push(this.createConnection());
        }
        
        console.log(`Pool #${this.instanceId} ready with ${this.connections.length} connections`);
    }
    
    private createConnection(): Connection {
        // Simulate connection establishment (1 second each)
        return new Connection();
    }
    
    /**
     * BROKEN: Race condition between check and assignment
     * 
     * Problem: The gap between "if (instance === null)" and 
     * "instance = new DatabaseConnectionPool()" allows multiple
     * threads to pass the check simultaneously
     */
    public static getInstance(): DatabaseConnectionPool {
        // DANGER ZONE: This check-then-act is NOT atomic
        if (DatabaseConnectionPool.instance === null) {
            // Multiple threads can reach here simultaneously!
            DatabaseConnectionPool.instance = new DatabaseConnectionPool();
        }
        return DatabaseConnectionPool.instance;
    }
    
    public getConnection(): Connection {
        return this.connections[Math.floor(Math.random() * this.connections.length)];
    }
    
    public getInstanceId(): number {
        return this.instanceId;
    }
}
 
// Simulated concurrent access (pseudocode - actual threading varies by runtime)
async function demonstrateRaceCondition() {
    const promises = [];
    
    // Launch 10 "threads" simultaneously
    for (let i = 0; i < 10; i++) {
        promises.push(
            (async () => {
                const pool = DatabaseConnectionPool.getInstance();
                console.log(`Thread ${i} got pool #${pool.getInstanceId()}`);
                return pool;
            })()
        );
    }
    
    const pools = await Promise.all(promises);
    
    // Check: are all pools the same instance?
    const uniquePools = new Set(pools.map(p => p.getInstanceId()));
    console.log(`Unique pools created: ${uniquePools.size}`);
    // EXPECTED (if safe): 1
    // ACTUAL (with race condition): could be 2, 3, or more!
}

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

/**
 * Thread-safe but inefficient lazy initialization
 * Correct, but pays synchronization cost on every access
 */
class ConfigurationService {
    private static instance: ConfigurationService | null = null;
    private static mutex = new Mutex();  // Hypothetical mutex
    
    private config: Map<string, string>;
    
    private constructor() {
        console.log("Loading configuration from remote service...");
        // Simulate expensive network call
        this.config = this.fetchConfigFromRemote();
    }
    
    private fetchConfigFromRemote(): Map<string, string> {
        // Simulate 2-second network delay
        return new Map([
            ["database.url", "postgres://localhost:5432/app"],
            ["cache.size", "1000"],
            ["log.level", "DEBUG"],
        ]);
    }
    
    /**
     * CORRECT but SLOW: Synchronize the entire method
     * 
     * Every call to getInstance() must acquire the lock, even when
     * the instance has already been created. This is wasteful.
     */
    public static async getInstance(): Promise<ConfigurationService> {
        // PERFORMANCE PROBLEM: Lock acquired on EVERY call
        await ConfigurationService.mutex.acquire();
        try {
            if (ConfigurationService.instance === null) {
                ConfigurationService.instance = new ConfigurationService();
            }
            return ConfigurationService.instance;
        } finally {
            ConfigurationService.mutex.release();
        }
    }
    
    public get(key: string): string | undefined {
        return this.config.get(key);
    }
}
 
/**
 * Performance Analysis:
 * 
 * First call:
 *   - Acquire lock: ~1μs
 *   - Check null: ~1ns
 *   - Create instance: ~2000ms
 *   - Release lock: ~1μs
 *   - Total: ~2000ms (acceptable)
 *
 * Subsequent calls (the problem):
 *   - Acquire lock: ~1μs
 *   - Check null: ~1ns
 *   - Return instance: ~1ns
 *   - Release lock: ~1μs
 *   - Total: ~2μs (should be ~1ns!)
 *
 * In a hot path called 1 million times/second:
 *   - With lock: 1,000,000 × 2μs = 2 seconds of lock contention
 *   - Without lock: 1,000,000 × 1ns = 1 millisecond
 *   
 * That's a 2000x slowdown!
 */