Question

I am slightly surprised by what I get if I compile and run the following (horrible non-synchronized) Java SE program.

public class ThreadRace {

    // this is the main class.

    public static void main(String[] args) {

        TestRunnable tr=new TestRunnable(); // tr is a Runnable.
        Thread one=new Thread(tr,"thread_one");
        Thread two=new Thread(tr,"thread_two");

    one.start();
    two.start(); // starting two threads both with associated object tr.
    }
}

class TestRunnable implements Runnable {
    int counter=0; // Both threads can see this counter.

    public void run() {
    for(int x=0;x<1000;x++) {
        counter++;
    }
        // We can't get here until we've added one to counter 1000 times.
        // Can we??

    System.out.println("This is thread "+
      Thread.currentThread().getName()+" and the counter is "+counter);
    }
}

If I run “java ThreadRace” at the command line, then here is my interpretation
of what happens. Two new threads are created and started. The threads have
the same Runnable object instance tr, and so they see the same tr.counter .
Both new threads add one to this counter 1000 times, and then print the value
of the counter.

If I run this lots and lots of times, then usually I get output of the form

This is thread thread_one and the counter is 1000
This is thread thread_two and the counter is 2000

and occasionally I get output of the form

This is thread thread_one and the counter is 1204
This is thread thread_two and the counter is 2000

Note that what happened in this latter case was that thread_one finished
adding one to the counter 1000 times, but thread_two had started adding
one already, before thread_one printed out the value of the counter.
In particular, this output is still comprehensible to me.

However, very occasionally I get something like

This is thread thread_one and the counter is 1723
This is thread thread_two and the counter is 1723

As far as I can see, this “cannot happen”. The only way the System.out.println() line
can be reached in either thread, is if the thread has finished counting to 1000.
So I am not bothered if one of the threads reports the counter as being some
random number between 1000 and 2000, but I cannot see how both threads can
get as far as their System.out.println() line (implying both for loops have finished,
surely?) and counter not be 2000 by the time the second statement is printed.

Is what is happening that both threads somehow attempt to do counter++ at exactly
the same time, and one overwrites the other? That is, a thread can even be
interrupted even in the middle of executing a single statement?

Answer 1

The “++” operator is not atomic — it doesn’t happen in one uninterruptible cycle. Think of it like this:

1. Fetch the old value
2. Add one to it
3. Store the new value back

So imagine that you get this sequence:

Thread A: Step 1
Thread B: Step 1
Thread A: Step 2
Thread B: Step 2
Thread A: Step 3
Thread B: Step 3

Both threads think they’ve incremented the variable, but its value has only increased by one! The second “store back” operation effectively cancels out the result of the first.

Now, truth is, when you add in multiple levels of cache, far weirder things can actually happen; but this is an easy explanation to understand. You can fix these kinds of issues by synchronizing access to the variable: either the whole run() method, or the inside of the loop using a synchronized block. As Jon suggests, you could also use some of the fancier tools in java.util.concurrent.atomic.