Bloqueo de nivel de objeto en Java

Cada objeto en Java tiene un bloqueo único. Siempre que estemos usando una palabra clave sincronizada, solo el concepto de bloqueo aparecerá en la imagen. Si un hilo quiere ejecutar un método sincronizado en el objeto dado. Primero, tiene que obtener un bloqueo de ese objeto. Una vez que el subproceso obtuvo el bloqueo, se le permite ejecutar cualquier método sincronizado en ese objeto. Una vez que se completa la ejecución del método, el subproceso libera automáticamente el bloqueo. JVM se encarga de adquirir y liberar el bloqueo internamente y el programador no es responsable de estas actividades.

Un bloqueo a nivel de objeto es un mecanismo cuando queremos sincronizar un método no estático o un bloque de código no estático de modo que solo un subproceso pueda ejecutar el bloque de código en una instancia determinada de la clase. 

Si un hilo quiere ejecutar un método sincronizado en el objeto dado. Primero, tiene que obtener un bloqueo de ese objeto. Una vez que el subproceso obtuvo el bloqueo, se le permite ejecutar cualquier método sincronizado en ese objeto. Una vez que se completa la ejecución del método, el subproceso libera automáticamente el bloqueo. JVM se encarga de adquirir y liberar el bloqueo internamente y el programador no es responsable de estas actividades.

Métodos: Hay diferentes formas en que podemos bloquear el objeto en el hilo como se muestra a continuación:

Método 1:

public class GeekClass
{
    public synchronized void GeekMethod(){}
}

Método 2:

public class GeekClass
{
    public void GeekMethod(){
        synchronized (this)
        {
            // other thread safe code
        }
    }
}

Método 3:

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

Ejemplo:

// Java program to illustrate
// Object lock concept
 
// Class
// Extending Runnable interface
class Geek implements Runnable {
 
    // Method of this class
    public void run() { Lock(); }
 
    // Synchronization of non-static methods
    // (object lock) as different synchronized
    // non-static methods are called in both threads
 
    // Then both threads need to acquire the object lock
    // After one is acquired, the other thread must wait
    // for one thread to finish the executing
    // before the other thread starts to execute.
    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");
        }
    }
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating an object of above class
        // in the main() method
        Geek g = new Geek();
 
        // Sharing the same object across two Threads
 
        // Here, t1 takes g
        Thread t1 = new Thread(g);
       
        // Here, t2 takes g
        Thread t2 = new Thread(g);
 
        // Creating another object of above class
        Geek g1 = new Geek();
 
        // Here, t3 takes g1
        Thread t3 = new Thread(g1);
 
        // setname() method is used to change
        // name of the thread
        t1.setName("t1");
        t2.setName("t2");
        t3.setName("t3");
 
        // start() method beginning the execution of threads
        // as JVM calls the run() method of thread
        t1.start();
        t2.start();
        t3.start();
    }
}

t1
t3
t2
in block t1
in block t3
in block t1 end
in block t2
in block t2 end
in block t3 end