Bloqueo de nivel de objeto frente a bloqueo de nivel de clase en Java

Synchronized es el modificador aplicable solo para métodos y bloques, pero no para clases y variables. Si varios subprocesos intentan operar simultáneamente en el mismo objeto Java, entonces puede haber una posibilidad de que haya un problema de inconsistencia de datos. Para superar este problema, deberíamos buscar una palabra clave » sincronizada «. Si un método o bloque se declara sincronizado, entonces solo un subproceso puede ejecutar ese método o bloque en el objeto dado a la vez para que se resuelva el problema de inconsistencia de datos. El concepto de sincronización interna se implementa mediante el bloqueo. 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 subproceso quiere ejecutar un método sincronizado en el objeto dado primero, debe obtener un bloqueo de ese objeto una vez que el subproceso obtuvo el bloqueo, entonces se le permite ejecutar cualquier método sincronizado en ese objeto. JVM se encarga de adquirir y liberar el bloqueo internamente y el programador no es responsable de esta actividad. Mientras un subproceso ejecuta un método sincronizado en el objeto dado, los subprocesos restantes no pueden ejecutar ningún método sincronizado simultáneamente en el mismo objeto. Pero los subprocesos restantes pueden ejecutar métodos no sincronizados simultáneamente.

El bloqueo de nivel de objeto es un mecanismo en el que cada objeto en Java tiene un bloqueo único que no es más que un bloqueo de nivel de objeto. Si un subproceso quiere ejecutar un método sincronizado en el objeto dado, entonces el subproceso primero requirió el bloqueo de nivel de objeto una vez que el subproceso obtiene el bloqueo de nivel de objeto, entonces se le permite ejecutar cualquier método sincronizado en el objeto dado y una vez que la ejecución del método se completó automáticamente subproceso libera la cerradura de ese objeto.

Ejemplo:

// 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();
    }
}

El bloqueo de nivel de clase es un mecanismo en el que cada clase en Java tiene un bloqueo único que no es más que un bloqueo de nivel de clase. Si un subproceso desea ejecutar un método sincronizado estático, entonces el subproceso requiere un bloqueo de nivel de clase una vez que el subproceso obtiene un bloqueo de nivel de clase, entonces se le permite ejecutar cualquier método sincronizado estático de esa clase. Una vez que se completa la ejecución del método, el subproceso libera automáticamente el bloqueo. Mientras un subproceso ejecuta un método sincronizado estático, el subproceso restante no puede ejecutar ningún método sincronizado estático de esa clase simultáneamente.

Ejemplo:

// 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();
    }
}