静态同步方法和非同步静态方法混淆

Question

I have a small confusion. Please have a look at the code below.

public class ThreadDemo {
  //non-static synchronized method
  synchronized void a(){
   actBusy();
  }

  //static synchronized method
  static synchronized void b(){
    actBusy();
  }

  //static method
  static void actBusy(){
    try{
      Thread.sleep(1000);
    }
    catch(InterruptedException e) {
      e.printStackTrace();
    }
  }

  public static void main(String[] args){
    final ThreadDemo x = new ThreadDemo();
    final ThreadDemo y = new ThreadDemo();
    Runnable runnable = new Runnable() {
      public void run() {
         int option = (int) (Math.random() * 4);
         switch (option){
           case 0: x.a();
             break;
           case 1: x.b();
             break;
           case 2: y.b();
             break;
           case 3: y.b();
             break;
         }
      }
    }   ;
    Thread t1 = new Thread(runnable);
    Thread t2 = new Thread(runnable);
    t1.start();
    t2.start();
  }
}

I know for sure that invocation of this sequence is possible.

x.a() //in Thread-1
y.b() //in Thread-2

Though still I have a small confusion that, we can easily see xa() also calls actBusy() method which is a static method. Method b() is a static synchronized method calling a non-synchronized static method. When thread-2 gets a class level lock, the why call of actBusy() from Thread-1 is not blocked?

I am just logically confused, if a thread gets a class level lock, that class other non-synchronized static methods remain open to be called from other methods (instance method). Why?

Answer 1

then why call of actBusy() from Thread-1 is not blocked?

Since your actBusy method is NOT synchronized. Even if you acquired class level lock you can invoke non-synchronzied static methods.

The point of marking the methods as synchronized is to enable locks. Only methods declared as synchronized are subjects to these locks. So if you acquired a lock (suppose class level lock) then any non-synchronized method acts as before and isn't aware of lock being acquired. This allows you to decide which methods need to be blocked and which don't.

Answer 2

static synchronized method has a lock on the class object , while non static synchronized method has a lock on the instance object ( this ) - so both methods can be invoked concurrently, and one thread will run 1 while the other run the 2nd.

However, note that there is no race condition available in your code, because race condition requires a write, and such does not exist in these methods.

Answer 3

actBusy() is itself not synchronized but the callers methods are.

So Thread 1 does not block as it acquires lock on this object and no other thread holds lock on this , so it is able to call it without any problem.

That is because the non-static synchronized method locks on this the present instance and not on class object.

xa() grabs a lock on the present instance ie x and no other thread will be able to enter method a() of x until the present the present thread releases the lock.

Thread 1 --> xa() //acquires lock and holds it

Thread 2 ---> xa() //blocks here until Thread 1 releases lock on x

EDIT:

Class Object != Instance 

So according to JMM they are different objects and two threads don't interfere with each other. So it allows you to call it.

EDIT 2:

why does it allow calls to other static methods? Any logic behind it?

Suppose this:

public static synchronized int statefulMethod(){
    //this should be protected
}

public static int nonStatefulMethod(){
    //Just returns a static value such as 5
    //so this is thread safe as it does not have any state
}

public static synchronized int otherStatefulMethod(){
    //this should also be thread safe
}

So if thread 1 is in method statefulMethod() which is having some shared state to protect so it uses class level lock. Now thread 2 calls nonStatefulMethod() then it should not logically block as that method is thread safe and there is no point in making that thread block here .

Now if thread 3 calls the otherStatefulMethod() while thread 1 is holding class lock then thread 3 will have to wait as that method is also static-synchornized .

Answer 4

Lock objects are not hierarchical. Therefore obtaining a lock on the class itself does not supersede locks on instances of your class. They are separate lock objects and will only block code that attempts to lock on exactly that same object.

So if a thread enters a static synchronized method, the only threads that will be blocked are those also trying to enter a static synchronized method on the same class. Threads that are merely trying to enter an non-static synchronized method are unaffected - they are only competing against threads trying to enter non-static synchronized methods on that same object instance.

Regarding your comment below - only static methods marked synchronized are subject to the class level lock. If you want other static methods to be blocked, you must also mark them synchronized .

Why is this the case? Well, it would be rather presumptuous for the compiler to assume you need to lock all your static methods simply because one is marked as synchronized . It is assumed that the programmer knows which methods must be synchronized in order to ensure thread safety.