El método java.util.concurrent.LinkedTransferQueue .getWaitingConsumerCount() devuelve la cantidad de consumidores que esperan recibir elementos a través de take() o sondeo cronometrado, desde LinkedTransferQueue (LTQ). Los consumidores aquí leerán elementos del LTQ. Los productores agregarán elementos al LTQ. Este método será útil solo cuando se estén ejecutando varios subprocesos, es decir, el productor está transfiriendo mensajes y los consumidores los están recibiendo simultáneamente. Los consumidores intentarán leer el encabezado del LTQ. Si no pueden (LTQ vacío o la cabeza ya se ha tomado), se dice que están esperando . Los consumidores esperarán hasta que lleguen a leer la cabeza, o hasta que transcurra un cierto límite de tiempo. Cuando un productor agrega al LTQ a través de transferencia(), se dice que esbloqueado _ Esto significa que el productor tiene que esperar hasta que un consumidor lea el elemento para agregar otro elemento al LTQ.
Sintaxis:
public int getWaitingConsumerCount()
Parámetros: este método no acepta parámetros.
Valor devuelto: este método devuelve un valor int , que es el número de consumidores que esperan la cabeza del LTQ, obtenido a través de take().
Ejemplo: El siguiente programa utiliza un productor y 3 consumidores. El productor envía 3 mensajes. El consumidor que llame primero a take() recibirá el último mensaje. Así, diferentes ejecuciones de este programa pueden llevar a diferentes consumidores a obtener diferentes mensajes.
// Java program to show LinkedTransferQueue
// getWaitingConsumerCount() method
import java.util.concurrent.*;
public class GFG {
// create object of LinkedTransferQueue
LinkedTransferQueue<Integer> LTQ
= new LinkedTransferQueue<>();
class Producer implements Runnable {
@Override
public void run()
{
for (int i = 0; i < 3; i++) {
try {
System.out.println("Producer is"
+ " waiting to transfer...");
// add 0, 1, 2 to LTQ
LTQ.transfer(i);
System.out.println("Producer "
+ "transferred element: " + i);
// display how many consumers are waiting
// after producer has transferred element
System.out.println("Waiting consumer "
+ "count after transfer: "
+ LTQ
.getWaitingConsumerCount());
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Consumer implements Runnable {
int id;
Consumer(int id)
{
this.id = id;
}
@Override
public void run()
{
try {
System.out.println("Consumer "
+ id
+ " is waiting to "
+ "take element...");
// display how many consumers are waiting
// before a consumer has taken element from LTQ
System.out.println("Waiting consumer"
+ " count before take: "
+ LTQ
.getWaitingConsumerCount());
Integer s = LTQ.take();
System.out.println("Consumer "
+ id
+ " received Element: "
+ s);
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws InterruptedException
{
// class object to keep common LTQ for all consumers
//(alternative: LTQ can be declared static)
GFG obj = new GFG();
// enabling multiple threads
ExecutorService exService
= Executors.newFixedThreadPool(3);
// declare one producer and 3 consumers
Producer producer = obj.new Producer();
Consumer consumer0 = obj.new Consumer(0);
Consumer consumer1 = obj.new Consumer(1);
Consumer consumer2 = obj.new Consumer(2);
// start producer and consumers
exService.execute(producer);
exService.execute(consumer0);
exService.execute(consumer1);
exService.execute(consumer2);
// stop
exService.shutdown();
}
}
Producción:
Nota: Se muestra la salida en NetBeans 8.2. Se recomienda probar este ejemplo localmente porque utiliza subprocesos múltiples. Es posible que los servidores IDE en línea no admitan esto o le permitan agregar dicha carga, lo que genera un error de límite de tiempo excedido.
Publicación traducida automáticamente
Artículo escrito por sreeragiyer y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA