How to Fix Race Condition in Java

Stumbled on a race condition in your Java application? This common issue has a well-known fix that you can apply in minutes.

Understanding Race Conditions

A race condition in Java occurs when two or more concurrent operations access shared state, and the outcome depends on their execution timing. This leads to intermittent bugs that are notoriously difficult to reproduce because they depend on specific timing that may rarely occur in testing but frequently occurs under production load.

The Fix

private final ReentrantLock lock = new ReentrantLock();

public int updateCounter(int id) {
    lock.lock();
    try {
        Counter counter = db.findById(id)
            .orElseThrow(() -> new NotFoundException("Counter not found"));
        counter.setValue(counter.getValue() + 1);
        db.save(counter);
        return counter.getValue();
    } finally {
        lock.unlock();
    }
}

// Alternative: use database-level locking
@Transactional
public int updateCounterOptimistic(int id) {
    // @Version field on entity handles optimistic locking
    Counter counter = db.findById(id).orElseThrow();
    counter.setValue(counter.getValue() + 1);
    return db.save(counter).getValue();
}

Use ReentrantLock with try/finally for in-memory locking, or JPA @Version for optimistic database-level locking.

Detection Strategies

• Add structured logging with timestamps around critical sections to identify interleaving
• Use stress testing and concurrent load testing to increase the probability of reproducing the race
• Review all shared mutable state that is accessed from async code paths or multiple threads
• Consider database-level locking (SELECT FOR UPDATE, optimistic locking) for distributed systems

Prevention

• Prefer immutable data structures where possible
• Use atomic operations for simple counters and flags
• Design APIs to be idempotent so duplicate executions are harmless

Race conditions are among the hardest bugs to catch in testing. [Bugsly](https://bugsly.dev) helps by correlating error timing patterns and identifying failures that cluster under high concurrency in your Java application.