了解Java中的同步方法示例

Question

I was reading this link . http://tutorials.jenkov.com/java-concurrency/synchronized.html .

The example is :

public class Counter{

  long count = 0;

   public synchronized void add(long value){
     this.count += value;
     System.out.println("Thread="+Thread.currentThread().getId()+"value ="+count);
   }
}

public class CounterThread extends Thread{

 protected Counter counter = null;

 public CounterThread(Counter counter){
    this.counter = counter;
 }

 public void run() {
  for(int i=0; i<10; i++){
       counter.add(i);
    }
 }
}


public class Jenkov2 {

public static void main(String[] args){
  Counter counter = new Counter();
  Thread  threadA = new CounterThread(counter);
  Thread  threadB = new CounterThread(counter);


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

When in run this on my system ,it always gives fixed output.

    Thread=9value =0
    Thread=9value =1
    Thread=9value =3
    Thread=9value =6
    Thread=9value =10
    Thread=9value =15
    Thread=9value =21
    Thread=9value =28
    Thread=9value =36
    Thread=9value =45
    Thread=10value =45
    Thread=10value =46
    Thread=10value =48
    Thread=10value =51
    Thread=10value =55
    Thread=10value =60
    Thread=10value =66
    Thread=10value =73
    Thread=10value =81
    Thread=10value =90

I run it multiple times but output is always same. I was expecting it to be switching between the two threads, value will be 90 after both the threads are done. As per me it will be like this : thread A run method is called, i is 0, 0 will be add and as method is synchronized,it will return after adding zero,then before next iteration of i inside for loop,context switching may occur and thread B runs and value 0 will be added.

Is my understanding correct and the output can also vary between threads or i am missing some concept.

Answer 1

Each time one of your threads goes around its loop, it releases the lock, and then immediately tries to lock it again.

Looks like on your system, the locking mechanism has no "fairness" to it, and the thread that just let go of the lock is able to grab it again before the other thread even knows it was released.

It could behave differently on some other system. But then again, you never know.

Change your run() method if you want to try what @Zabuza suggested,

public void run() {
    for(int i=0; i<10; i++){
        counter.add(i);
        Thread.sleep(10);
    }
 }

The sleep call will give the other thread a chance to wake up and grab the lock.