有和没有静态变量的Java同步

Question

I have been studying about synchronization in java and tried to run the following program

    public class Example {
        public static void main(String[] args) {
            Counter counterA = new Counter();
            Counter counterB = new Counter();
              Thread  threadA = new CounterThread(counterA);
              Thread  threadB = new CounterThread(counterB);

              threadA.start();
              threadB.start(); 
        }
    }

    class CounterThread extends Thread {
        protected Counter counter = null;

        public CounterThread(Counter counter){
           this.counter = counter;
        }
        public void run() {
        for(int i=0; i<2; i++){
              counter.add(i);
           }
        }
    }

    class Counter {
         long count = 0;
         public synchronized void add(long value){
          this.count += value;
          System.out.println(this.count);
        }
    }

when i run the above code , it gives me the same output when i run Example class as java application or when i debug the Example class

 0
 1
 0
 1

But if i modify the access modifier of count variable of counter class as static like mentioned below :

    static long count = 0;

and now if try to run the Example class i get the output as

 0
 1
 0
 2

but when i debug the Example class i get the output as

 0
 1
 1
 2

Can anyone help me to understand the difference. Thanks in advance and apologies because i am new to multithreading concepts

Answer 1

Each instance has its own copy of instance variable(s) but they share the static variable. As you have two instances of your class and two threads operating on these instances:

        Counter counterA = new Counter();
        Counter counterB = new Counter();
        Thread  threadA = new CounterThread(counterA);
        Thread  threadB = new CounterThread(counterB);

So the effect is clear. When the count is non-static, two threads do not affect the count of two different objects. But when count is static, two threads work on the same variable shared by two instances.

When you have two independent threads in action, the execution order is dynamic depending on how Thread Scheduler picks a thread to execute. Using a debugger not necessarily does affect it , infact you may see different result with normal execution of your program.

Answer 2

synchronized only protects you from two callers entering a method on the same instance at the same time. So it basically does not affect your example at all.

Non-static case: Each thread is updating its own Counter.count instance. You can get either 0-1-0-1 or 0-0-1-1 (much less likely) as output.

Static case: Each thread is updating the same Counter.count via two different Counter instances. You can get either 0-0-1-2, 0-1-1-2 AND 0-1-0-2.

Why the last option? You only affect a static Coutner.count instance, not a static Counter instance. So both threads can be inside Counter.add and one thread may have already loaded 0 for outputting it, but the other threads then updates it and outputs 1 and only then the first thread outputs its 0.

Which of 0-0-1-2, 0-1-1-2 or 0-1-0-2 you get is not defined at all and does NOT depend on debug & release modes. It is quite common, however, to receive different results in debug & release modes due to differences in the assembly code produced by the compiler.