Java多线程非静态和静态方法的行为保持不变

Question

When I synchronize non static method and static method the behavior remains the same. Thread locks the instance for both static and non staitc methods when i put synchronized(Task.class) in both the cases

public class ThreadDemo {
    public static void main(String[] args) {

        for(int i=0;i<10;i++){
            Task task =new Task();
            new Thread(task).start();
        }
    }
}
class Task implements Runnable {

    @Override
    public void run() {
        printThreadName();

    }

    public  void printThreadName() {
        synchronized (Task.class) {


        System.out.println("Starting-->"+Thread.currentThread().getName());
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("Ending->"+Thread.currentThread().getName());
        }
    }

}

and after making the method static

public  static  void printThreadName() {
        synchronized (Task.class) {


        System.out.println("Starting-->"+Thread.currentThread().getName());
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("Ending->"+Thread.currentThread().getName());
        }
    }

Every Thread locks this class until it completes and so on. My question is why this behavior is same even for non static method in the first case.

Answer 1

I'll summarize the comments above:

The JLS states the following: (emphasis by me)

If the method is an instance method , it locks the monitor associated with the instance for which it was invoked (that is, the object that will be known as this during execution of the body of the method). If the method is static , it locks the monitor associated with the Class object that represents the class in which the method is defined.

So this will synchronize on the instance:

public synchronized void someMethod() { ... }

This will synchronize on the class:

public static synchronized void someMethod() { ... }

When you use a synchronized block inside a method you need to provide the monitor which can be a class (eg Myclass.class ) or any object instance (which could be this ):

synchronized(monitor) { ... }

You could use synchronized(getClass()) or synchronized(this) to get behavior very similar to method level synchronization (I'm not sure whether the getClass() variant would behave the same in all cases).