Método LinkedTransferQueue hasWaitingConsumer() en Java

El método Java.util.concurrent.LinkedTransferQueue .hasWaitingConsumer() siempre devuelve verdadero si hay al menos un consumidor en la cola esperando recibir un elemento a través de BlockingQueue.take() o sondeo cronometrado. El valor devuelto representa un estado momentáneo de las cosas.

Sintaxis

public boolean hasWaitingConsumer()

Parámetros: No toma ningún parámetro.

Valor devuelto: este método devuelve un valor booleano que es verdadero si al menos un consumidor está presente en la cola.

A continuación se muestran algunos ejemplos para ilustrar el método LinkedTransferQueue.hasWaitingConsumer():

Ejemplo 1:

// Java code to demonstrate
// hasWaitingConsumer() method
  
import java.util.concurrent.LinkedTransferQueue;
  
class GFG {
    public static void main(String args[])
    {
        LinkedTransferQueue<String> LTQ
            = new LinkedTransferQueue<String>();
  
        LTQ.add("Geeks");
        LTQ.add("For");
        LTQ.add("Geeks");
        LTQ.add("GeeksForGeeks");
  
        System.out.println(LTQ.hasWaitingConsumer());
    }
}
Producción:

false

Ejemplo 2:

// Java code to demonstrate
// hasWaitingConsumer() method
  
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedTransferQueue;
  
public class GFG {
  
    LinkedTransferQueue<Integer> LTQ
        = new LinkedTransferQueue<>();
  
    class LTQProducer implements Runnable {
  
        @Override
        public void run()
        {
            for (int i = 0; i < 3; i++) {
                try {
                    System.out.println("Producer is"
                                       + " waiting to transfer");
                    LTQ.transfer(i);
                    System.out.println("Producer transferred"
                                       + " element: "
                                       + i);
                    System.out.println("Is there any consumer"
                                       + " still waiting to"
                                       + " receive an element"
                                       + " after transfer -> "
                                       + LTQ.hasWaitingConsumer());
                }
                catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
  
    class LTQConsumer implements Runnable {
        int id;
        LTQConsumer(int id)
        {
            this.id = id;
        }
  
        @Override
        public void run()
        {
            try {
                System.out.println("Consumer "
                                   + id
                                   + " is waiting to "
                                   + "take an element.");
                System.out.println("Is there any consumer"
                                   + " still waiting to"
                                   + " receive an element"
                                   + " after transfer -> "
                                   + LTQ.hasWaitingConsumer());
                Integer s = LTQ.take();
                System.out.println("Consumer "
                                   + id
                                   + " received Element: "
                                   + s);
            }
            catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
  
    // Driver code
    public static void main(String[] args)
        throws InterruptedException
    {
        GFG ob = new GFG();
  
        ExecutorService exService
            = Executors.newFixedThreadPool(3);
  
        LTQProducer p = ob.new LTQProducer();
        LTQConsumer c1 = ob.new LTQConsumer(0);
        LTQConsumer c2 = ob.new LTQConsumer(1);
  
        exService.execute(p);
        exService.execute(c1);
        exService.execute(c2);
  
        exService.shutdown();
    }
}
Producción:

El productor está esperando para transferir
El consumidor 0 está esperando para tomar un elemento.
¿Hay algún consumidor esperando para tomar un elemento? -> false
El consumidor 1 está esperando para tomar un elemento.
¿Hay algún consumidor esperando para tomar un elemento -> falso
Consumidor 0 elemento recibido: 0 Elemento
transferido por el productor: 0
¿Hay algún consumidor esperando recibir un elemento después de la transferencia -> verdadero
Productor está esperando para
transferir Elemento transferido por el productor: 1
Consumidor 1 Elemento recibido: 1
¿Hay algún consumidor todavía esperando recibir un elemento después de la transferencia -> falso El
productor está esperando para transferir ?

Publicación traducida automáticamente

Artículo escrito por psil123 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *