Object Level Lock vs Class Level Lock in Java

Synchronized is the modifier applicable only for methods and blocks but not for classes and variables. If multiple threads are trying to operate simultaneously on the same java object then there may be a chance of data inconsistency problem to overcome this problem we should go for a ‘synchronized‘ keyword. If a method or block declares as synchronized then at a time only one thread is allowed to execute that method or block on the given object so that the data inconsistency problem will be resolved. Internally synchronization concept is implemented by using the lock. Every object in java has a unique lock. Whenever we are using a ‘synchronized‘ keyword then only the lock concept will come into the picture.

If a thread want’s to execute a synchronized method on the given object first it has to get a lock of that object once the thread got the lock then it is allowed to execute any synchronized method on that object. Acquiring and releasing lock internally takes care of by JVM and the programmer is not responsible for this activity. While a thread executing a synchronized method on the given object the remaining threads are not allowed to execute any synchronized method simultaneously on the same object. But remaining threads are allowed to execute non-synchronized methods simultaneously.

Object Level Lock is a mechanism where every object in java has a unique lock which is nothing but an object–level lock. If a thread wants to execute a synchronized method on the given object then the thread first required the object level lock once the thread gets object level lock then it is allowed to execute any synchronized method on the given object and once the method execution completed automatically thread releases the lock of that object.

Example:

Java

// Java program to illustrate Object Level Lock Concept

// Import required packages
import java.io.*;
import java.util.*;

// Class 1
// Helper Class 1
// Consists of synchronized method wish
class Display {

    // Declaring Non-static wish method
    public void wish(String name)
    {

        // synchronizing wish method
        // and getting the lock of current object
        synchronized (this)
        {

            for (int i = 1; i <= 10; i++) {

                // display message only
                System.out.print("Good Morning: ");

                // Try block to check. for exceptions
                try {

                    // Putting thread on sleep for specified
                    // time
                    // using the sleep() method
                    Thread.sleep(1000);
                }

                // Catch block to handle the exceptions
                catch (InterruptedException e) {

                    // Print the occurred exception/s
                    System.out.println(e);
                }
                // Display message only
                System.out.println(name);
            }
        }
    }
}

// Class 2
// Helper Class 2 (extending main Thread Class)
// myThread with override the run method and
// consists of parameterized constructor
class myThread extends Thread {
    // member variable of this class
    Display d;
    String name;

    // Constructor(Parameterized) of this class
    myThread(Display d, String name)
    {

        // this keyword refers to current object itself
        this.d = d;
        this.name = name;
    }

    // run() method for thread
    public void run()
    {

        // Calling wish method of display class
        d.wish(name);
    }
}

// Class 3
// Main Class
class GFG {

    // Main driver method
    public static void main(String[] args)
    {

        // Creating display class(Class 1) object
        // in the main() method
        Display d = new Display();

        // Creating thread objects in main method()
        myThread t1 = new myThread(d, "Dhoni");
        myThread t2 = new myThread(d, "Yuvraj");

        // Starting the threads using the start() method
        t1.start();
        t2.start();
    }
}

Class Level Lock is a mechanism where every class in java has a unique lock which is nothing but a class level lock. If a thread wants to execute a static synchronized method then the thread requires a class level lock once the thread gets a class level lock then it is allowed to execute any static synchronized method of that class. Once method execution completes automatically thread releases the lock. While a thread executing a static synchronized method the remaining thread is not allowed to execute any static synchronized method of that class simultaneously.

Example:

Java

// java program to illustrate Class Level Lock Concept

// Importing required packages
import java.io.*;
import java.util.*;

// Class 1
// Helper Class
// Consist of synchronized method wish
class Display {

    // Declaring static wish method
    public static void wish(String name)
    {

        // synchronizing wish method
        // and getting the lock of display class
        synchronized (Display.class)
        {

            for (int i = 1; i <= 10; i++) {

                // Display message only
                System.out.print("Good Morning: ");

                // Try block to check for exceptions
                try {
                    // Putting thread on sleep for specified
                    // time
                    //  using the sleep() method
                    Thread.sleep(1000);
                }

                // Catch block to handle the exception
                catch (InterruptedException e) {

                    // Throwing exception
                    System.out.println(e);
                }
                // Display message
                System.out.println(name);
            }
        }
    }
}

// C;asss 2
// Helper Class (extends the Thread class)
// myThread with override the run method
// as per our requirements it also consists
// of parameterized constructor
class myThread extends Thread {
    // Member variables of this class
    Display d;
    String name;

    // Constructor of this class
    myThread(Display d, String name)
    {

        // This keyword refers to current object itself
        this.d = d;
        this.name = name;
    }

    // run method for thread/s
    public void run()
    {

        // Calling wish method of display class
        d.wish(name);
    }
}

// Class 3
// Main Class
class GFG {

    // Main driver method
    public static void main(String[] args)
    {

        // Creating Display class(Class 1) object
        // in the main() method
        Display d = new Display();

        // Creating a thread objects
        myThread t1 = new myThread(d, "Dhoni");
        myThread t2 = new myThread(d, "Yuvraj");

        // Starting the threads using start() method
        t1.start();
        t2.start();
    }
}

Class Level Lock	Object Level Lock
This lock can be used when we want to prevent multiple threads to enter the synchronized block of available instances on runtime.	This lock is used when we want a non-static method or non-static block of our code should be accessed by only one thread at a time.
This lock is used to make static data thread-safe.	This lock is used to make non-static data thread-safe.
Multiple objects of a particular class may exist but there is always one class’s class object lock available.	Every object the class have their own lock.
We can get a class level lock as follows: public class GFG {   public void m1( ) {      synchronized (GFG.class) {     // some line of code    } }	We can get object level lock as follows: public class GFG {   public void m1( ) {      synchronized (this) {         // some line of code      }   } }