Difference between Synchronized Block and Method in Java

Synchronized block and synchronized methods are two techniques to create mutual exclusion on crucial parts of code in Java using synchronized keywords. Since Java is mainly useful to write multi-threading programs, which present various kinds of thread-related issues like thread-safety, deadlock, and race conditions. It plagues into code mainly because of poor understanding of the synchronization mechanism provided by the Java programming language. To implement synchronization in Java, the language includes built-in synchronized and volatile keywords.
The key distinction between the synchronized technique and the synchronized block is that the synchronized method uses a different set of locks to lock the vital region.
A synchronized method that depends on whether it’s a static or non-static lock on the class level or object level.
Each class has its own lock, which is represented by a class literal, such as Stirng.class.

A current object, such as this instance, provides the object-level lock. In Java, you should never mix static and non-static synchronized methods.

Synchronized blocks, on the other hand, lock on the monitor based on the expression provided as an input to the synchronized block.
We’ll look at an example of both a synchronized method and a synchronized block in the next section.

Difference between synchronized method vs block in Java

Based on experience and syntactical rules of the synchronized keyword in Java, here are some more differences between synchronized method and block in Java.
Although both blocks and methods can be used to offer the highest level of synchronization in Java, synchronized blocks are considered to be a better Java coding practice.

1. Scope of lock

Here is an example of a sample class that shows on which object synchronized method and block are locked and how to use them :

/**
  * Java class to demonstrate the use of synchronization method and block in Java
  */
public class SycnronizationExample{
  
  
    public synchronized void lockedByThis(){
        System.out.println(" This synchronized method is locked by current" instance of object i.e. this");
    }
  
    public static synchronized void lockedByClassLock(){
        System.out.println("This static synchronized method is locked by class level lock of this class i.e. SychronizationExample.class");

    }
  
    public void lockedBySynchronizedBlock(){
        System.err.println("This line is executed without locking");
      
        Object obj = String.class; //class level lock of Stirng class
      
        synchronized(obj){
            System.out.println("synchronized block, locked by lock represented using obj variable");
        }
    }
      
}