Slow performance when multiple threads access static variable

Question

Originally, I was trying to keep track of the number of function calls for a specific function that was called across many threads. I initially implemented this by incrementing a static variable, and noticed some pretty horrible performance. Does anyone have an ideas?
(I know this code is "incorrect" since increments are not atomic, even with a volatile keyword)
Essentially, I'm running two threads that try to increment a variable a billion times each. The first time through, they increment a shared static variable. As expected, the result is wrong 1339999601 instead of 2 billion, but the funny thing is it takes about 14 seconds. Now, the second time through, they increment a local variable and add it to the static variable at the end. This runs correctly (assuming the final increment doesn't interleave which is highly unprobable) and runs in about a second.
Why the performance hit? I'm not even using volatile (just for refernce if I make the variable volatile runtime hits about 30 seconds)
Again I realize this code is incorrect, this is purely an interesting side-expirement.
package gui;
public class SlowExample implements Runnable
     public static void main(String[] args)
          SlowExample se1 = new SlowExample(1, true);
          SlowExample se2 = new SlowExample(2, true);
          Thread t1 = new Thread(se1);
          Thread t2 = new Thread(se2);
          try
               long time = System.nanoTime();
               t1.start();
               t2.start();
               t1.join();
               t2.join();
               time = System.nanoTime() - time;
               System.out.println(count + " - " + time/1000000000.0);
               Thread.sleep(100);
          catch (InterruptedException e)
               e.printStackTrace();
          count = 0;
          se1 = new SlowExample(1, false);
          se2 = new SlowExample(2, false);
          t1 = new Thread(se1);
          t2 = new Thread(se2);
          try
               long time = System.nanoTime();
               t1.start();
               t2.start();
               t1.join();
               t2.join();
               time = System.nanoTime() - time;
               System.out.println(count + " - " + time/1000000000.0);
          catch (InterruptedException e)
               e.printStackTrace();
           * Results:
           * 1339999601 - 14.25520115
           * 2000000000 - 1.102497384
     private static int count = 0;
     public int ID;
     boolean loopType;
     public SlowExample(int ID, boolean loopType)
          this.ID = ID;
          this.loopType = loopType;
     public void run()
          if (loopType)
               //billion times
               for (int a=0;a<1000000000;a++)
                    count++;
          else
               int count1 = 0;
               //billion times
               for (int a=0;a<1000000000;a++)
                    count1++;
               count += count1;
}

Answer 1

Peter__Lawrey wrote:
Your computer has different types of memory
- registers
- level 1 cache
- level 2 cache
- main memory.
- non CPU local main memory (if you have multiple CPUs with their own memory banks)
These memory types have different speeds. Depending on how you use a variable affects which memory it is placed in.Plus you have the hotspot compiler kicking in sometime during the run. In other words for some time the VM is interpreting the code and then all of a sudden its compiled and executing the code compiled. Reliable micro benchmarking in java is not easy. See [Robust Java benchmarking, Part 1: Issues|http://www.ibm.com/developerworks/java/library/j-benchmark1.html]