Race Conditions

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

public class RaceConditionExample {
    
    // EXAMPLE 1: Race condition WITH data race
    private int counter = 0;
    
    public void increment() {
        counter++;  // Data race: unsynchronized read+write
                    // Race condition: count might be wrong
    }
    
    // EXAMPLE 2: Race condition WITHOUT data race
    private final AtomicInteger atomicCounter = new AtomicInteger(0);
    
    public void incrementIfBelow(int threshold) {
        // Each operation is atomic (no data race)...
        int current = atomicCounter.get();     // Atomic read
        if (current < threshold) {              // Check...
            atomicCounter.incrementAndGet();    // Atomic increment
        }
        // ...but the COMPOUND operation is a race condition!
        // Between get() and incrementAndGet(), another thread
        // could have incremented past the threshold.
    }
    
    // EXAMPLE 3: This LOOKS synchronized but has a race condition
    private Map<String, Integer> syncMap = Collections.synchronizedMap(new HashMap<>());
    
    public void incrementMapValue(String key) {
        // Each individual operation is synchronized...
        Integer value = syncMap.get(key);       // Atomic read
        if (value == null) {
            syncMap.put(key, 1);                 // Atomic write
        } else {
            syncMap.put(key, value + 1);         // Atomic write
        }
        // ...but Thread A reads 5, Thread B reads 5,
        // Thread A writes 6, Thread B writes 6. Lost update!
    }
}

Consider a race condition with a 0.001% probability per operation.
 
Development testing:
- 1,000 test runs × 100 operations = 100,000 total operations
- Probability of seeing the bug: ~63% (might miss it!)
 
Production:
- 1,000 users × 100 operations/day × 30 days = 3,000,000 operations
- Expected occurrences: ~30 failures per month
- First failure likely within first day
 
This is why "it passed our tests" provides no confidence for concurrency.

# Go Race Detector (built-in, excellent!)
go run -race ./...
go test -race ./...
 
# C/C++ ThreadSanitizer
clang -fsanitize=thread -g myprogram.c
./a.out
 
# Java: Use FindBugs/SpotBugs for static analysis
spotbugs -textui -high myapp.jar
 
# Java: Run with concurrency stress testing
java -XX:+UseParallelGC -Xmx4G -jar stress-test.jar
 
# Python: Use pylint with threading checks
pylint --load-plugins=pylint.extensions.threading mymodule.py
 
# General: Use LLVM's ThreadSanitizer for any LLVM-compatible language

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

import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
 
public class PreventionExamples {
    
    // STRATEGY 1: Eliminate sharing - use message passing
    private final BlockingQueue<Task> taskQueue = new LinkedBlockingQueue<>();
    
    public void submitTask(Task task) { 
        taskQueue.put(task);  // No shared mutable state - just pass messages
    }
    
    // STRATEGY 2: Immutability
    public final class ImmutableUser {
        private final String id;
        private final String name;
        
        public ImmutableUser(String id, String name) {
            this.id = id;
            this.name = name;
        }
        // No setters - create new object when "changing"
        public ImmutableUser withName(String newName) {
            return new ImmutableUser(this.id, newName);
        }
    }
    
    // STRATEGY 3: Thread confinement
    private final ThreadLocal<SimpleDateFormat> dateFormat = 
        ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));
    
    public String formatDate(Date date) {
        return dateFormat.get().format(date);  // Each thread has its own
    }
    
    // STRATEGY 4: Atomic operations
    private final AtomicLong requestCount = new AtomicLong(0);
    private final AtomicReference<Config> currentConfig = new AtomicReference<>();
    
    public void recordRequest() {
        requestCount.incrementAndGet();  // Atomic increment
    }
    
    public void updateConfig(Config newConfig) {
        currentConfig.set(newConfig);  // Atomic reference update
    }
    
    // STRATEGY 5: Thread-safe collections with atomic operations
    private final ConcurrentMap<String, AtomicLong> perUserCounts = new ConcurrentHashMap<>();
    
    public void incrementUserCount(String userId) {
        perUserCounts.computeIfAbsent(userId, k -> new AtomicLong(0))
                     .incrementAndGet();  // Both operations are atomic
    }
    
    // STRATEGY 6: Proper synchronization for complex invariants
    private String firstName;
    private String lastName;
    private final Object nameLock = new Object();
    
    public void setName(String first, String last) {
        synchronized (nameLock) {
            this.firstName = first;
            this.lastName = last;  // Atomic update of both
        }
    }
    
    public String getFullName() {
        synchronized (nameLock) {
            return firstName + " " + lastName;  // Consistent read
        }
    }
}