持有监视器的Java线程

Question

I was reading about java threads and happened to read this blog. In the blog I came across a statement:

During the execution of a synchronized method, the thread holds the monitor for that method's object, or if the method is static, it holds the monitor for that method's class.

Can anyone please tell me what is the difference between:

• a thread is holding the monitor for methods object
• a thread is holding the monitor for methods class

Answer 1

It means that a synchronized instance method is broadly equivalent to:

public class FooClass {
    public void foo() {
        synchronized(this) {
            ...
        }
    }
}

Whereas a synchronized static method is broadly equivalent to:

public class FooClass {
    public static void foo() {
        synchronized(FooClass.class) {
            ...
        }
    }
}

So in the instance method case it will synchronize on an instance of FooClass (and calls to foo in other threads on other instances will not block), whereas in the static method case it synchronizes on the Class object itself.

Note that for the static method version, it's the class containing the method which is important - even if the method is notionally called "on" a subclass (eg SubFooClass.foo() ) the method still obtains a monitor on the class in which it's declared.

See JLS section 8.4.3.6 for more details.

Answer 2

You can rougly translate, in a class Foo , say:

public synchronized foo()
{
    doSomething();
}

to:

public foo()
{
    synchronized(this) {
        doSomething();
    }
}

Whereas:

public static synchronized foo()
{
    doSomething();
}

translates (roughly) to:

public static foo()
{
    synchronized(Foo.class) {
        doSomething();
    }
}

In the first case, you synchronize against the current instance of Foo ( this ). In the second case, you synchronize against the Class object (all Class objects are singletons, this is why it works).

Answer 3

on a non static method, the lock is on the instance (this); ie your method is equivalent to:

public void method(){
    synchronised(this){
        //my code
    }
}

on a static method, there is no instance (you can't reference this in a static method). So the lock is on the actual class object (MyObject.class).

public static void method(){
    synchronised(MyClass.class){
        //my code
    }
}

Hence with 1 synchronised methods and 1 synchronised static method, the two can execute at the same time as they nothing prevents them from running in parallel, the locks being on different objects.