Use los métodos wait() y notificar() en Java

Este tutorial demuestra los métodos wait() y notify() en Java.

Usa los métodos wait() y notify() en Java

Los métodos wait() y notify() proporcionan un mecanismo para permitir que el hilo espere hasta que se cumpla una condición específica. Por ejemplo, cuando desea escribir la implementación de la cola de bloqueo para un almacén de elementos de respaldo de tamaño fijo.

El esperar () y notificar () se utilizan en los bloques protegidos en Java, que coordinan las acciones de múltiples hilos. El método esperar() se usa para suspender un hilo y notificar() para reactivarlo.

el método esperar()

El método wait() forzará al subproceso actual a esperar hasta que se completen otros subprocesos, o invoquen los métodos notify() o notifyAll() en el mismo objeto. Los métodos wait() se pueden utilizar de las siguientes maneras diferentes:

1. Usando esperar():

   Esta es la simple llamada del método wait(), que hará que el subproceso actual espere indefinidamente hasta que los otros subprocesos invoquen los métodos notify() o notifyAll().

2. Usando esperar (tiempo de espera prolongado):

   Con esta llamada del método wait(), podemos especificar un tiempo de espera, después del cual el subproceso se activará automáticamente, donde el tiempo de espera es un valor de tiempo prolongado.

   El subproceso también se puede despertar antes del tiempo de espera utilizando los métodos notify() y notifyAll(). Poner el valor 0 en el parámetro de tiempo de espera funcionará de manera similar a la llamada esperar ().

3. Usando esperar (tiempo de espera largo, int nanos):

   Esta llamada también funcionará de manera similar a esperar (tiempo de espera prolongado). La única diferencia es que podemos proporcionar una mayor precisión.

   El período de tiempo de espera se calcula en nanosegundos como 1_000_000*tiempo de espera + nanos.

los métodos notify() y notifyAll()

La funcionalidad notificar () se utiliza para despertar los subprocesos que esperan acceder al monitor de objetos. La funcionalidad notify() se puede utilizar de dos formas:

1. Usando notificar():

   Para todos los subprocesos en espera, el método notify() notificará solo a un subproceso específico para que se despierte. La selección del subproceso para despertar no es determinista, lo que depende de la implementación.

   Dado que notify() solo puede activar un hilo, puede que no sea útil cuando queremos activar varios hilos.

2. Usando notifyAll():

   El notifyAll() activará todos los subprocesos en el monitor de objetos. Cuando se despiertan los subprocesos, se completarán de la manera habitual como los otros subprocesos.

Probemos un ejemplo que bloquea los hilos usando el método wait() y se despierta usando el método notify():

package delftstack;

import java.util.LinkedList;
import java.util.Queue;

public class Example<T> {
  private Queue<T> Demo_Queue = new LinkedList<T>();
  private int Q_Capacity;

  public Example(int Q_Capacity) {
    this.Q_Capacity = Q_Capacity;
  }

  public synchronized void put(T Demo_Element) throws InterruptedException {
    while (Demo_Queue.size() == Q_Capacity) {
      wait();
    }

    Demo_Queue.add(Demo_Element);
    // Wake up the thread. notifyAll() can also be used for multiple threads
    notify();
  }

  public synchronized T take() throws InterruptedException {
    while (Demo_Queue.isEmpty()) {
      // Ask the thread to wait
      wait();
    }

    T item = Demo_Queue.remove();
    // Wake up the thread. notifyAll() can also be used for multiple threads
    notify();
    return item;
  }
}

El código anterior demuestra una operación de bloqueo de cola simple en la que debemos asegurarnos de que cualquier llamada esperar () y notificar () estará en la región sincronizada del código.