Métodos de bloqueo en Java

Los métodos de bloqueo en Java son el conjunto particular de métodos que bloquean el hilo hasta que se completa su operación. Por lo tanto, tendrán que bloquear el hilo actual hasta que se cumpla la condición que cumple con su tarea. Dado que, en la naturaleza, estos métodos bloquean los llamados métodos de bloqueo. Por ejemplo, el método InputStream read() bloquea hasta que todos los datos de InputStream se hayan leído por completo. Estos son algunos de los métodos de bloqueo de Java más comunes:

1. InvokeAndWait(): espera a que el subproceso del distribuidor de eventos ejecute el código.
2. InputStream.read(): bloquea hasta que los datos de entrada están disponibles, lanza una excepción o detecta el final de la transmisión.
3. ServerSocket.accept(): Escuche la conexión entrante del socket Java y los bloques hasta que se haya realizado una conexión.
4. CountDownLatch.await(): hace que el subproceso actual espere hasta que el pestillo cuente hasta cero, a menos que se interrumpa el subproceso.

Hay varias desventajas de los métodos de bloqueo:

• Las técnicas de bloqueo representan una amenaza importante para la escalabilidad del sistema. Una solución de bloqueo clásica consiste en formas de mitigar el bloqueo, utilizando múltiples subprocesos para atender a múltiples clientes.
• El diseño es el aspecto más importante, ya que incluso si un sistema de subprocesos múltiples no puede llegar más allá de cierto punto, un sistema mal diseñado solo puede admitir varios cientos o miles de subprocesos debido a la cantidad limitada de subprocesos JVM.

Implementación:

Aquí, en el siguiente ejemplo, después de la ejecución de la primera declaración de impresión, el programa será bloqueado por una segunda declaración de impresión hasta que se ingresen algunos caracteres en la consola. Luego haga clic en enter porque read() bloquea el método hasta que alguna entrada sea legible.

Ejemplo 1:

// Java Program to illsutare Blocking methods
 
// Importing all input output classes
import java.io.*;
 
// Class
class GFG {
 
   // main driver method
   public static void main(String args[]) throws FileNotFoundException, IOException 
 
   {
     // Print statement
     System.out.println("GFG");
 
     int result;
     result = System.in.read();
      
     // Print statement
     System.out.println("Geeks for Geeks");
 
   } 
 
}

GFG
Geeks for Geeks

Ejemplo 2:

Aquí, en este ejemplo, CountDownLatch.await() se usa cuando un subproceso necesita esperar a otros subprocesos antes de comenzar su trabajo. El método CountDown() disminuye los bloques de método count y wait() hasta count == 0.

// Java Program to illsutare Blocking methods
 
// Importing all input output classes
import java.io.*;
// Importing concurrent CountDownLatch class
// from java.util package
import java.util.concurrent.CountDownLatch;
 
// Class
class GFG {
 
    // Main driver method
    public static void main(String args[])
        throws InterruptedException
    {
        // Let us create task that is going to wait
        // for five threads before it starts
        CountDownLatch latch = new CountDownLatch(4);
 
        // Creating threads of Person type
        // Custom parameter inputs
        Person p1 = new Person(1500, latch, "PERSON-1");
        Person p2 = new Person(2500, latch, "PERSON-2");
        Person p3 = new Person(3500, latch, "PERSON-3");
        Person p4 = new Person(4500, latch, "PERSON-4");
        Person p5 = new Person(5500, latch, "PERSON-5");
 
        // Starting the thread
        // using the start() method
        p1.start();
        p2.start();
        p3.start();
        p4.start();
        p5.start();
 
        // Waiting for the four threads
        // using the latch.await() method
        latch.await();
 
        // Main thread has started
        System.out.println(Thread.currentThread().getName()
                           + " has finished his work");
    }
}
 
// Class 2
// Helper class extending Thread class
// To represent threads for which the main thread waits
class Person extends Thread {
    // Member variables of this class
    private int delay;
    private CountDownLatch latch;
 
    // Method of this class
    public Person(int delay, CountDownLatch latch,
                  String name)
    {
        // super refers to parent class
        super(name);
 
        // This keyword refers to current object itself
        this.delay = delay;
        this.latch = latch;
    }
 
    @Override public void run()
    {
        // Try block to check for exceptions
        try {
            Thread.sleep(delay);
            latch.countDown();
 
            // Print the current thread by getting its name
            // using the getName() method
            // of whose work is completed
            System.out.println(
                Thread.currentThread().getName()
                + " has finished his work");
        }
 
        // Catch block to handle the exception
        catch (InterruptedException e) {
            // Print the line number where exception occurred
            // using the printStackTrace() method
            e.printStackTrace();
        }
    }
}

PERSON-1 has finished his work
PERSON-2 has finished his work
PERSON-3 has finished his work
PERSON-4 has finished his work
main has finished his work
PERSON-5 has finished his work