Java同步方法-OCPJP

Question

I'm reading a book regarding to the OCPJP exam. It says

An entire method can be declared synchronized. In that case, when the method declared as synchronized is called, a lock is obtained on the object on which the method is called, and it is releases when the method returns to the caller.

What I got from this phrase;

If there is a class called A, which calls a synchronized method, resides in the class B, is acquiring the lock from an object of class A (which the method is called).

Is it correct or not?

Does it need to acquire the lock from an object of class B? Just like synchronized block using this reference.

Answer 1

If there is a class called A, which calls a synchronized method, resides in the class B, is acquiring the lock from an object of class A (which the method is called).

No, in this case object of class B will be used as lock, since the method belongs to Class B

Answer 2

The lock is on the B-object that is used by A. This object can be anywhere, in my example it is in class A, but it could be passed to A through a parameter of the execute()-method.

Imagine this:

public class A{
    public B objectB;

    public void execute(){
        objectB = new B();

        // objectB is synchronized during the execution of the following call, no other        
        // Thread can access ANY synchronized method of objectB or any 
        // synchonized(this) block within objectB in this time
        objectB.syncedMethod();   
    }
}

public class B{
    public synchronized void syncedMethod(){
        //doImportantStuff
    }

    public synchronized void anotherSyncmethod(){
        //do other important stuff
    }
}

The effect is same like synchronizing on "this" inside the method (I guess the resulting Java bytecode will be different, see comments)

public class B{
    public void syncedMethod(){
      synchronized(this){
        //doImportantStuff
      }
    }

    public void anotherSyncmethod(){
        synchronized(this){
         //do other important stuff
        }
    }
}

Answer 3

Every object has a lock associated with it and all of its synchronized methods have to acquire its lock before enter the method. So, if any thread calls m1() or m2() on the object depicted in the diagram above, it has to acquire the lock on the object which contains m1() or m2() and not on itself.