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