Class level lock versus Object level lock

[Anirudh Bhatnagr]

If I make a method static then the thread executing that method would acquire class level lock , now if another thread tries to access some other method of the same class, would it have to wait until the first thread releases the lock on class.

So my question is : Does a class level lock lock the entire class ?

[amit punekar]

Hi,
If another thread wants to access same or another STATIC method then it will have to wait for the Class level lock to be released.

So my question is : Does a class level lock lock the entire class ?

Class level lock is required to execute the synchronized methods/blocks those have Static identifier. Static means its the CLASS level method and hence you have to obtain CLASS Level lock.

For synchronized instance methods which are invoked using an object of the class, need a lock on the object to be obtained before its invocation.

Regards,
Amit

[Anirudh Bhatnagr]

So does a class level lock stop a thread to acquire Object level lock of that class

[Chris Hurst]

No ! :-)

A class level object just locks the associated class object shared effectively (by association) between the instances, each object has its own lock. Locking on the class object is still just locking on an object is not really that magical when you get your head round it.

[Anirudh Bhatnagr]

So if the class level lock is just another lock on the class object.
Then apart from providing a locking mechanism for static methods what else can be achieved?

[Andrey Kozhanov]

And what do you want to achive? Let's review the following code

public class Test {
    public static void main(String[] args) throws Exception {
        new Thread(new Runnable() {
            public void run() {
                try {
                    Test.m1();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();

        Thread.sleep(1000);

        new Thread(new Runnable() {
            public void run() {
                new Test().m2();
            }
        }).start();
    }

    public static synchronized void m1() throws Exception {
        // The following code is actually synchronized on Test.class object.
        System.out.println("m1 is started");
        Thread.sleep(2000);
        System.out.println("m1 is completed");
    }

    public void m2() {
        // This code is not synchronized.
        System.out.println("m2 is working");
    }
}

The output will be:

m1 is started
m2 is working
m1 is completed

If you want the output to be

m1 is started
m1 is completed
m2 is working

i.e. m2 method is started only after m1 is finished, then you should synchronize m2 code on the same object as m1, that is Test.class object, like this:

public void m2() {
    synchronized(Test.class) {
        System.out.println("m2 is working");
    }
}

[Snehal Masne]

Object level locking:

Object level locking is mechanism when you want to synchronize a non-static method or non-static code block such that only one thread will be able to execute the code block on given instance of the class. This should always be done to make instance level data thread safe. This can be done as below :

    public class DemoClass 
    { 
      public synchronized void demoMethod(){} 
    } 
    
    or 
    
    public class DemoClass 
    { 
      public void demoMethod(){ 
      synchronized (this) 
      { 
       //other thread safe code 
      } 
     } 
    } 
    
    or 
    
    public class DemoClass 
    { 
      private final Object lock = new Object(); 
      public void demoMethod(){ 
      synchronized (lock) 
     { 
      //other thread safe code 
     } 
    } 

Class level locking:

Class level locking prevents multiple threads to enter in synchronized block in any of all available instances on runtime. This means if in runtime there are 100 instances of DemoClass, then only one thread will be able to execute demoMethod() in any one of instance at a time, and all other instances will be locked for other threads. This should always be done to make static data thread safe.

    public class DemoClass 
    { 
      public synchronized static void demoMethod(){} 
    } 
    
    or 
    
    public class DemoClass 
    { 
      public void demoMethod(){ 
      synchronized (DemoClass.class) 
      { 
       //other thread safe code 
      } 
     } 
    } 
    
    or 
    
    public class DemoClass 
    { 
     private final static Object lock = new Object(); 
     public void demoMethod(){ 
     synchronized (lock) 
      { 
       //other thread safe code 
      } 
     } 
    }