Shared Mutable State Problems

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

// Conceptual example of shared mutable state hazards
// (Actual JavaScript is single-threaded in main context, but Worker threads can share memory)
 
class BankAccount {
    private balance: number;
    
    constructor(initialBalance: number) {
        this.balance = initialBalance;
    }
    
    // HAZARD 1: Data Race
    // Two threads reading/writing 'balance' without synchronization
    getBalance(): number {
        return this.balance;  // Read may see stale/partial value
    }
    
    // HAZARD 2: Race Condition (check-then-act)
    // Even if getBalance() and setBalance() were atomic individually...
    withdraw(amount: number): boolean {
        if (this.balance >= amount) {  // Thread A: balance=100, amount=60 → true
                                        // Thread B: balance=100, amount=60 → true
            // ...context switch here...
            this.balance -= amount;     // Thread A: balance = 40
                                        // Thread B: balance = -20 (INVARIANT VIOLATED!)
            return true;
        }
        return false;
    }
    
    // HAZARD 3: Compound operation non-atomicity
    transfer(other: BankAccount, amount: number): boolean {
        if (this.withdraw(amount)) {    // Step 1: Deduct from this
            // System crashes here → money is lost!
            other.deposit(amount);       // Step 2: Add to other
            return true;
        }
        return false;
    }
    
    deposit(amount: number): void {
        this.balance += amount;  // Read-modify-write: NOT atomic!
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class SessionManager {
    // Shared mutable state
    private int activeSessionCount = 0;
    
    public void onSessionStart() {
        activeSessionCount++;   // Read (1) → Add (2) → Write (3)
    }
    
    public void onSessionEnd() {
        activeSessionCount--;
    }
    
    public int getActiveCount() {
        return activeSessionCount;
    }
}

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

import java.util.concurrent.atomic.AtomicInteger;
 
public class SessionManager {
    // Thread-safe atomic counter
    private final AtomicInteger activeSessionCount = new AtomicInteger(0);
    
    public void onSessionStart() {
        activeSessionCount.incrementAndGet();  // Atomic: read+add+write as ONE operation
    }
    
    public void onSessionEnd() {
        activeSessionCount.decrementAndGet();
    }
    
    public int getActiveCount() {
        return activeSessionCount.get();
    }
}
 
// OR: Using synchronized
 
public class SessionManagerSync {
    private int activeSessionCount = 0;
    private final Object lock = new Object();
    
    public void onSessionStart() {
        synchronized (lock) {
            activeSessionCount++;  // Protected by lock
        }
    }
    
    public void onSessionEnd() {
        synchronized (lock) {
            activeSessionCount--;
        }
    }
    
    public int getActiveCount() {
        synchronized (lock) {
            return activeSessionCount;
        }
    }
}

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

import java.util.*;
import java.util.concurrent.*;
 
public class SubtleSharingExamples {
    
    // Example 1: Closure captures
    private int counter = 0;  // Instance field
    
    public void runInBackground() {
        Runnable task = () -> {
            counter++;  // BUG: 'counter' is captured and now shared
                        // with whatever thread runs this Runnable!
        };
        executor.submit(task);
    }
    
    // Example 2: Container contents become shared
    private final List<User> users = new CopyOnWriteArrayList<>();  // Thread-safe list
    
    public void registerUser(User user) {
        users.add(user);  // Now 'user' is accessible from any thread
                          // reading the list. Is User itself thread-safe?
    }
    
    public void updateAllUsers() {
        for (User user : users) {
            user.incrementLoginCount();  // BUG: User might not be thread-safe!
        }
    }
    
    // Example 3: Memoization creates shared state
    private volatile ExpensiveObject cached;  // Lazy singleton pattern
    
    public ExpensiveObject getExpensive() {
        if (cached == null) {
            cached = new ExpensiveObject();  // BUG: Multiple threads might 
                                              // create multiple instances!
        }
        return cached;  // The returned object is now shared
    }
    
    // Example 4: Return value sharing
    public List<String> getActiveUserNames() {
        List<String> names = new ArrayList<>();
        // ... populate names ...
        return names;  // BUG: If caller stores this reference,
                       // and another thread calls this method,
                       // they might get the same ArrayList instance!
    }
    
    // Example 5: External resource sharing
    private final FileWriter logFile;  // External state
    
    public void log(String message) {
        logFile.write(message);  // BUG: FileWriter isn't thread-safe!
                                  // Concurrent writes corrupt output.
    }
    
    private final ExecutorService executor = Executors.newFixedThreadPool(4);
}

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

public class UserService {
    
    // REVIEW POINT 1: Is this shared?
    // - It's an instance field of UserService
    // - UserService might be a singleton (need to check)
    // - ConcurrentHashMap is thread-safe for individual operations
    private final Map<String, User> cache = new ConcurrentHashMap<>();  // ✓ OK
    
    // REVIEW POINT 2: Is this shared?
    // - Instance field, mutable (not final, even if effectively so)
    // - Multiple threads could access via getUserStats()
    private long totalLogins = 0;  // ❌ UNSAFE: read-modify-write
    
    // REVIEW POINT 3: Method parameter analysis
    public void login(User user) {  // Is 'user' thread-safe?
        
        user.setLastLoginTime(now());  // ❌ If User is shared, this mutates shared state!
        
        cache.put(user.getId(), user);  // ❌ After this, 'user' IS shared via cache
        
        totalLogins++;  // ❌ RACE CONDITION: read-modify-write not atomic
    }
    
    // REVIEW POINT 4: Return value analysis
    public User getUser(String id) {
        return cache.get(id);  // ❌ Caller receives reference to shared User
                               // Any mutations by caller affect shared state!
    }
    
    // REVIEW POINT 5: Compound operation
    public User getOrCreate(String id, Supplier<User> factory) {
        User user = cache.get(id);       // ← Thread A reads null
        if (user == null) {              // ← Thread B reads null
            user = factory.get();         // ← Both create new User
            cache.put(id, user);          // ← Thread A puts its User
        }                                 // ← Thread B overwrites with its User!
        return user;                      // ❌ RACE: factory called twice, wrong user returned
    }
    
    // CORRECT: Use atomic compute operation
    public User getOrCreateCorrect(String id, Supplier<User> factory) {
        return cache.computeIfAbsent(id, k -> factory.get());  // ✓ Atomic
    }
}