Object level and Class level locks in Java - GeeksforGeeks

10 Mar, 2021
Synchronization: 
Synchronization is a modifier that is used for the method and blocks only. With the help of a synchronized modifier, we can restrict a shared resource to be accessed only by one thread. When two or more threads need access to shared resources, there is some loss of data i.e. data inconsistency. The process by which we can achieve data consistency between multiple threads is called Synchronization.
Why do you need Synchronization? 
Let us assume if you have two threads that are reading and writing to the same ‘resource’. Suppose there is a variable named geek, and you want that at one time only one thread should access the variable(atomic way). But Without the synchronized keyword, your thread 1 may not see the changes thread 2 made to geek, or worse, it may only be half changed that cause the data inconsistency problem. This would not be what you logically expect. The tool needed to prevent these errors is synchronization.
In synchronization, there are two types of locks on threads:  
Object-level 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 wants to execute then synchronized method on the given object. First, it has to get a lock-in that object. Once the thread got the lock then it is allowed to execute any synchronized method on that object. Once method execution completes automatically thread releases the lock. Acquiring and release lock internally is taken care of by JVM and the programmer is not responsible for these activities. Let’s have a look at the below program to understand the object level lock:
JAVA
// Java program to illustrate// Object lock conceptclass Geek implements Runnable {    public void run() { Lock(); }    public void Lock()    {        System.out.println(            Thread.currentThread().getName());        synchronized (this)        {            System.out.println(                "in block "                + Thread.currentThread().getName());            System.out.println(                "in block "                + Thread.currentThread().getName()                + " end");        }    }     public static void main(String[] args)    {        Geek g = new Geek();        Thread t1 = new Thread(g);        Thread t2 = new Thread(g);        Geek g1 = new Geek();        Thread t3 = new Thread(g1);        t1.setName("t1");        t2.setName("t2");        t3.setName("t3");        t1.start();        t2.start();        t3.start();    }}
t1
t3
t2
in block t3
in block t1
in block t3 end
in block t1 end
in block t2
in block t2 end

Class level lock: 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 a thread got the 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. Let’s look at the below program for better understanding:
JAVA
// Java program to illustrate class level lockclass Geek implements Runnable {    public void run() { Lock(); }     public void Lock()    {        System.out.println(            Thread.currentThread().getName());        synchronized (Geek.class)        {            System.out.println(                "in block "                + Thread.currentThread().getName());            System.out.println(                "in block "                + Thread.currentThread().getName()                + " end");        }    }     public static void main(String[] args)    {        Geek g1 = new Geek();        Thread t1 = new Thread(g1);        Thread t2 = new Thread(g1);        Geek g2 = new Geek();        Thread t3 = new Thread(g2);        t1.setName("t1");        t2.setName("t2");        t3.setName("t3");        t1.start();        t2.start();        t3.start();    }}
t1
t2
t3
in block t1
in block t1 end
in block t3
in block t3 end
in block t2
in block t2 end

Reference: https://docs.oracle.com/javase/tutorial/essential/concurrency/sync.html 
This article is contributed by Bishal Kumar Dubey. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
AyushBaheti
vishalmehatre16
Java-Class and Object
Java-Multithreading
Java
Java-Class and Object
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Interfaces in Java
ArrayList in Java
Multidimensional Arrays in Java
Singleton Class in Java
Stack Class in Java
Set in Java
LinkedList in Java
Collections in Java
Overriding in Java
Different ways of Reading a text file in Java