Question

I have a favorite C# program similar to the one below that shows that if two threads share the same memory address for counting (one thread incrementing n times, one thread decrementing n times) you can get a final result other than zero. As long as n is reasonably large, it’s pretty easy to get C# to display some non-zero value between [-n, n]. However, I can’t get Java to produce a non-zero result even when increasing the number of threads to 1000 (500 up, 500 down). Is there some memory model or specification difference wrt C# I’m not aware of that guarantees this program will always yield 0 despite the scheduling or number of cores that I am not aware of? Would we agree that this program could produce a non-zero value even if we can not prove that experimentally?

(Not:, I found this exact question over here, but when I run that topic’s code I also get zero.)

public class Counter
{
  private int _counter = 0;

  Counter() throws Exception
  {
    final int limit = Integer.MAX_VALUE;

    Thread add = new Thread()
    {
      public void run()
      {
        for(int i = 0; i<limit; i++)
        {
          _counter++;
        }
      }
    };

    Thread sub = new Thread()
    {
      public void run()
      {
        for(int i = 0; i<limit; i++)
        {
         _counter--;
        }
      }
    };

    add.run();
    sub.run();
    add.join();
    sub.join();

    System.out.println(_counter);
  }

  public static void main(String[] args) throws Exception
  {
    new Counter();
  }
}

Answer 1

The code you’ve given only runs on a single thread, so will always give a result of 0. If you actually start two threads, you can indeed get a non-zero result:

// Don't call run(), which is a synchronous call, which doesn't start any threads
// Call start(), which starts a new thread and calls run() *in that thread*.
add.start();
sub.start();

On my box in a test run that gave -2146200243.