Método Wait () en Java

En este artículo, veremos el método wait() para controlar el subproceso y los métodos notificar() / notificarTodos() . Estos métodos están definidos en la clase base java.lang.Object y, en consecuencia, los mecanismos de herencia que hay en Java proporcionan estos métodos a absolutamente todas las clases. Es decir, cuando crea su propia clase y sus objetos, siempre puede llamar a estos métodos.

¿Cómo funcionan los métodos esperar () y notificar ()/notificar a todos ()?

• esperar() . en resumen, este método libera el monitor y pone el subproceso de llamada en un estado de espera hasta que otro subproceso llama al método de notificación () / notificar a todos () ;
• notificar() . Continúa el trabajo de un hilo cuyo método wait() fue llamado previamente;
• El método de notificación a todos () reanuda todos los subprocesos a los que se les ha llamado previamente a su método de espera () .

Ahora echemos un vistazo más de cerca al método wait() . La clase Object contiene tres opciones para este método:

• public final native native void wait(long timeoutMillis) throws InterruptedException ; Hace que el subproceso actual espere hasta que se despierte. Suele ocurrir al ser notificado o interrumpido, o hasta que transcurre un cierto tiempo real.

• public final void wait() lanza InterruptedException . No es coincidencia que escribimos un método sin parámetros como el segundo. De hecho, si miras su código, se refiere a la primera variante del método, solo tiene el argumento 0L.

• espera final pública (tiempo de espera largo, int nanos) . Hace que el subproceso actual espere hasta que se despierte, normalmente mediante notificación o interrupción, o hasta que haya transcurrido una cierta cantidad de tiempo real.

El método wait() está destinado a suspender el hilo de llamada. ¿Qué significa? Estos métodos pertenecen a la clase. Basado en la clase, creas un objeto. Los objetos existen en algunos subprocesos. Es decir, los objetos se crean en algunos hilos. En el subproceso en el que funciona este objeto, si llama a wait() en él, esto conducirá al hecho de que este subproceso se detendrá. El objeto en sí actúa como una especie de monitor. ¿Qué es? Está claro que puedes crear diferentes objetos y todos ellos contendrán el wait()método. Hay una comprensión de qué objeto causó la detención de un subproceso en particular. El hilo se detiene y esperará mientras esté escrito en el parámetro. Y entonces comenzará. Este hilo no puede iniciarse solo. Para reanudar el trabajo, existen métodos de notificación y notificación a todos. Una llamada para notificar () o notificar a todos () debe reproducir algún otro hilo. Con wait() , puede detener varios subprocesos e iniciar todos los subprocesos con notificarTodos() . Si se detuvieron varios subprocesos y se llamó a notificar () , es imposible saber exactamente qué subproceso reanudará este método. Si no hay subprocesos en espera en el método wait() , entonces no sucede nada cuando se notifica() ose llama a notificarTodos() . Un subproceso puede llamar a los métodos esperar() o notificar() en un objeto en particular solo si actualmente tiene un bloqueo en ese objeto. wait () , notificar () y notificar a todos () solo deben llamarse desde el código sincronizado.

Ejemplo del método Wait()

Aquí tenemos uno de los ejemplos más populares que ilustra cómo funciona el método. Digamos que tenemos una tienda, un productor y un consumidor. El fabricante transfiere algunos productos de producción a la tienda, luego de lo cual el consumidor puede tomarlos. Deje que el fabricante tenga que producir 8 bienes, respectivamente, el consumidor debe comprarlos todos. Pero al mismo tiempo, no pueden estar más de 6 artículos en el almacén al mismo tiempo. Para resolver este problema, usamos los métodos wait() y notificar() . Definamos tres clases: Mercado , Fabricante y Cliente . El fabricante en el método run() agrega 8 productos al objeto Market usando sumétodo put() . El cliente en el método run() en un bucle llama al método get del objeto Market para obtener estos productos. Los métodos put y get de la clase Market están sincronizados. Para rastrear la presencia de bienes en la clase Mercado , verificamos el valor de la variable del artículo. El método get() para obtener un producto solo debería activarse si hay al menos un producto. Por lo tanto, en el método get, verificamos si falta el producto. Si el elemento no está disponible, se llama al método wait() . Este método libera el monitor del objeto Market y bloquea el método get hasta la notificación ()se llama al método en el mismo monitor. Cuando se agrega un elemento en el método put() y se llama a notificar() , el método get() obtiene el monitor. Después de eso, nuestro cliente recibe un artículo. Para ello, se muestra un mensaje y se decrementa el valor del artículo. Finalmente, la llamada al método de notificación () le indica al método put () que continúe. En el método put() , funciona una lógica similar, solo que ahora el método put() debería funcionar si no hay más de 6 productos en el mercado .

class Market {

   private int item = 0;

   public synchronized void get() {
       //here we use wait() method
       while (item < 1) {
           try {
               wait();
           }
           catch (InterruptedException e) {
           }
       }
       item--;
       System.out.println("A client has bought 1 item...");
       System.out.println("Items quantity in Market warehouse... " + item);
       notify();
   }

   public synchronized void put() {
       //here we use wait() method when the Warehouse is full
       while (item >= 6) {
           try {
               wait();
           }
           catch (InterruptedException e) {
           }
       }
       item ++;
       System.out.println("Manufacturer has added 1 more item...");
       System.out.println("Now there are " + item + " items in Warehouse" );
       notify();
   }
}

class Manufacturer implements Runnable {

   Market market;

   Manufacturer(Market market) {
       this.market = market;
   }


   public void run() {
       for (int i = 0; i < 8; i++) {
           market.put();
       }
   }
}

class Client implements Runnable {

   Market market;
   Client(Market market) {
       this.market = market;
   }
   public void run() {
       for (int i = 0; i < 8; i++) {
           market.get();
       }
   }
}
//wait() method test class
public class WaitTest {
   public static void main(String[] args) {

       Market market = new Market();
       Manufacturer manufacturer = new Manufacturer(market);
       Client client = new Client(market);
       new Thread(manufacturer).start();
       new Thread(client).start();
   }
}

Aquí, usando wait() en el método get() , estamos esperando que el fabricante agregue un nuevo artículo. Y después de agregar, llamamos a notificar () , como para decir que un lugar se ha vuelto libre en el Almacén , y puede agregar más. En el método put() , usando wait() , estamos esperando la liberación de espacio en el Almacén . Una vez que el espacio está libre, agregamos el elemento, notificar () inicia el hilo y el Cliente puede recoger el elemento. Aquí está la salida de nuestro programa: