Race conditions and why shared mutation breaks

Understanding Race conditions and why shared mutation breaks

A race condition is not a kind of crash, it is a dependency on timing. count++ looks indivisible because it is one expression, but it is three actions: read the field into the thread's own stack, add one to that copy, and store the result back. Between the read and the write a thread is holding a number that may already be out of date, so if a second thread reads the same original value, both compute the same result and both store it, and one increment vanishes. A field is a mailbox, not a ledger: the last writer wins and whatever arrived in between is overwritten without a trace.

The second shape of the same bug is check-then-act. A condition you test - the balance is large enough, the map has no entry for this key, the field is still null - is only true at the instant it is read; after that it is a guess about the past. Making the individual operations thread-safe does not help, because what has to be indivisible is the whole sequence from the check to the action that depends on it. An AtomicInteger guarantees that no single decrement is lost and still lets two threads both pass if (balance.get() >= amount) and push the balance negative.

Races resist testing because the losing interleaving is usually rare: it depends on core count, on how the JIT compiled the loop, and on what else the machine is doing, so code can behave for a year on a laptop and fail in a minute on a loaded server. The sleeps in the examples below do not create the bug, they pin down one schedule the scheduler is already free to choose. A race needs three ingredients at once - state that is shared, state that is mutated, and no ordering between the threads touching it - so removing any one of them removes the race: confine the state to a single thread, make it immutable, or make the whole compound action indivisible.

public class LostUpdate {
    static int count = 0;

    static void increment(String who) throws InterruptedException {
        int seen = count;                  // step 1: read
        System.out.println(who + " read " + seen);
        Thread.sleep(100);                 // the scheduler may pause here anyway
        int next = seen + 1;               // step 2: compute on a private copy
        count = next;                      // step 3: write back
        System.out.println(who + " wrote " + count);
    }

    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            try {
                increment(Thread.currentThread().getName());
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        };

        Thread a = new Thread(task, "A");
        Thread b = new Thread(task, "B");

        a.start();
        Thread.sleep(20);                  // let A get past its read first
        b.start();

        a.join();
        b.join();
        System.out.println("increments performed: 2, count = " + count);
    }
}

Worked examples

import java.util.concurrent.atomic.AtomicInteger;

public class CheckThenAct {
    static final AtomicInteger balance = new AtomicInteger(100);

    static void withdraw(String who, int amount) throws InterruptedException {
        if (balance.get() >= amount) {                 // check
            Thread.sleep(50);                          // the other thread slips in here
            int left = balance.addAndGet(-amount);     // act
            System.out.println(who + " withdrew " + amount + ", left " + left);
        } else {
            System.out.println(who + " declined, balance " + balance.get());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            try {
                withdraw(Thread.currentThread().getName(), 100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        };

        Thread t1 = new Thread(task, "T1");
        Thread t2 = new Thread(task, "T2");

        t1.start();
        Thread.sleep(10);
        t2.start();

        t1.join();
        t2.join();
        System.out.println("final balance " + balance.get());
    }
}

Important notes

Common mistakes

Try it yourself