Diferencia entre bloqueo y monitor en la concurrencia de Java

Java Concurrency básicamente se ocupa de conceptos como subprocesos múltiplesy otras operaciones concurrentes. Esto se hace para garantizar la utilización máxima y eficiente del rendimiento de la CPU, reduciendo así su tiempo de inactividad en general. Han existido bloqueos para implementar subprocesos múltiples mucho antes de que los monitores hayan llegado al uso. En aquel entonces, los bloqueos (o mutex) eran partes de subprocesos dentro del programa que trabajaban en mecanismos de bandera para sincronizarse con otros subprocesos. Siempre han estado funcionando como una herramienta para proporcionar control de acceso síncrono sobre recursos y objetos compartidos. Con más avances, el uso de monitores comenzó como un mecanismo para manejar el acceso y coordinar subprocesos que demostraron ser más eficientes, libres de errores y compatibles en programas orientados a objetos. Antes de continuar para encontrar las diferencias entre los dos, echemos un vistazo más de cerca a cada uno de ellos.

Descripción general de Lock (o Mutex)

El bloqueo originalmente se ha utilizado en la sección lógica de los subprocesos que se utilizaron para proporcionar un control de acceso sincronizado entre los subprocesos. Los subprocesos verificaron la disponibilidad del control de acceso sobre los objetos compartidos a través de indicadores adjuntos al objeto que indicaban si el recurso compartido está libre (desbloqueado) u ocupado (bloqueado) o no. Ahora, la API de simultaneidad brinda soporte para usar bloqueos explícitamente usando la interfaz de bloqueo en Java. El método explícito tiene un mecanismo de control más fino en comparación con la implementación implícita de bloqueos mediante monitores. Antes de pasar a hablar de los monitores, veamos una ilustración que demuestra el funcionamiento de las cerraduras básicas.

Supervisar: descripción general

Monitor en Java Concurrency es un mecanismo de sincronización que proporciona los requisitos fundamentales de subprocesos múltiples, a saber, la exclusión mutua entre varios subprocesos y la cooperación entre subprocesos que trabajan en tareas comunes. Los monitores básicamente ‘supervisan’ el control de acceso de recursos y objetos compartidos entre subprocesos. Usando esta construcción, solo un subproceso a la vez obtiene control de acceso sobre la sección crítica en el recurso, mientras que otros subprocesos se bloquean y se hacen esperar hasta que se den ciertas condiciones. En Java, los monitores se implementan utilizando la palabra clave sincronizada (bloques sincronizados, métodos o clases sincronizados). Por ejemplo, veamos cómo se sincronizan dos hilos t1 y t2 para usar un objeto de impresora de datos compartidos. 

// Java Program to Illustrate Monitoe in Java Concurrency
 
// Importing input output classes
import java.io.*;
 
// Class 1
// Helper class
class SharedDataPrinter {
 
    // Monitor implementation is carried on by
    // Using synchronous method
 
    // Method (synchronised)
    synchronized public void display(String str)
    {
 
        for (int i = 0; i < str.length(); i++) {
            System.out.print(str.charAt(i));
 
            // Try-catch bloc kfor exceptions as we are
            // using sleep() method
            try {
 
                // Making thread to sleep for very
                // nanoseconds as passed in the arguments
                Thread.sleep(100);
            }
            catch (Exception e) {
            }
        }
    }
}
 
// Class 2
// Helper class extending the Thread class
class Thread1 extends Thread {
 
    SharedDataPrinter p;
 
    // Thread
    public Thread1(SharedDataPrinter p)
    {
 
        // This keyword refers to current instance itself
        this.p = p;
    }
 
    // run() method for this thread invoked as
    // start() method is called in the main() method
    public void run()
    {
 
        // Print statement
        p.display("Geeks");
    }
}
 
// Class 2 (similar to class 1)
// Helper class extending the Thread class
class Thread2 extends Thread {
 
    SharedDataPrinter p;
 
    public Thread2(SharedDataPrinter p) { this.p = p; }
 
    public void run()
    {
 
        // Print statement
        p.display(" for Geeks");
    }
}
 
// Class 3
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Instance of a shared resource used to print
        // strings (single character at a time)
        SharedDataPrinter printer = new SharedDataPrinter();
 
        // Thread objects sharing data printer
        Thread1 t1 = new Thread1(printer);
        Thread2 t2 = new Thread2(printer);
 
        // Calling start methods for both threads
        // using the start() method
        t1.start();
        t2.start();
    }
}

Producción:

Finalmente, para terminar con el artículo, analicemos las principales diferencias entre Lock y Monitor en concurrencia en Java que se representa gráficamente en la imagen a continuación que se muestra a continuación: 

Nota: 

Como vemos, los monitores en sí mismos se implementan con el apoyo necesario de las cerraduras, a menudo se dice que no son diferentes sino complementarios en la naturaleza de su existencia.