Concurrencia Java - Interfaz BlockingQueue

Una interfaz java.util.concurrent.BlockingQueue es una subinterfaz de la interfaz Queue y, además, admite operaciones como esperar a que la cola no esté vacía antes de recuperar un elemento y esperar a que haya espacio disponible en la cola antes de almacenar un elemento. .

Métodos BlockingQueue

No Señor. Método y descripción
1

boolean add(E e)

Inserta el elemento especificado en esta cola si es posible hacerlo inmediatamente sin violar las restricciones de capacidad, devolviendo verdadero en caso de éxito y lanzando una IllegalStateException si no hay espacio disponible actualmente.
2

boolean contains(Object o)

Devuelve verdadero si esta cola contiene el elemento especificado.
3

int drainTo(Collection<? super E> c)

Elimina todos los elementos disponibles de esta cola y los agrega a la colección dada.
4

int drainTo(Collection<? super E> c, int maxElements)

Elimina como máximo el número dado de elementos disponibles de esta cola y los agrega a la colección dada.
5

boolean offer(E e)

Inserta el elemento especificado en esta cola si es posible hacerlo inmediatamente sin violar las restricciones de capacidad, devolviendo verdadero en caso de éxito y falso si no hay espacio disponible actualmente.
6

boolean offer(E e, long timeout, TimeUnit unit)

Inserta el elemento especificado en esta cola, esperando hasta el tiempo de espera especificado si es necesario para que haya espacio disponible.

7

E poll(long timeout, TimeUnit unit)

Recupera y elimina el encabezado de esta cola, esperando hasta el tiempo de espera especificado si es necesario para que un elemento esté disponible.
8

void put(E e)

Inserta el elemento especificado en esta cola, esperando si es necesario hasta que haya espacio disponible.
9

int remainingCapacity()

Devuelve el número de elementos adicionales que esta cola puede aceptar idealmente (en ausencia de limitaciones de memoria o recursos) sin bloquear, o Integer.MAX_VALUE si no hay un límite intrínseco.
10

boolean remove(Object o)

Elimina una única instancia del elemento especificado de esta cola, si está presente.
11

E take()

Recupera y elimina el encabezado de esta cola, esperando si es necesario hasta que un elemento esté disponible.

Ejemplo

El siguiente programa TestThread muestra el uso de la interfaz BlockingQueue en un entorno basado en subprocesos.

import java.util.Random;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class TestThread {

   public static void main(final String[] arguments) throws InterruptedException {
      BlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(10);

      Producer producer = new Producer(queue);
      Consumer consumer = new Consumer(queue);

      new Thread(producer).start();
      new Thread(consumer).start();

      Thread.sleep(4000);
   }  


   static class Producer implements Runnable {
      private BlockingQueue<Integer> queue;

      public Producer(BlockingQueue queue) {
         this.queue = queue;
      }

      @Override
      public void run() {
         Random random = new Random();

         try {
            int result = random.nextInt(100);
            Thread.sleep(1000);
            queue.put(result);
            System.out.println("Added: " + result);
            
            result = random.nextInt(100);
            Thread.sleep(1000);
            queue.put(result);
            System.out.println("Added: " + result);
            
            result = random.nextInt(100);
            Thread.sleep(1000);
            queue.put(result);
            System.out.println("Added: " + result);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }	   
   }

   static class Consumer implements Runnable {
      private BlockingQueue<Integer> queue;

      public Consumer(BlockingQueue queue) {
         this.queue = queue;
      }
      
      @Override
      public void run() {
         
         try {
            System.out.println("Removed: " + queue.take());
            System.out.println("Removed: " + queue.take());
            System.out.println("Removed: " + queue.take());
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }
   }
}

Esto producirá el siguiente resultado.

Salida

Added: 52
Removed: 52
Added: 70
Removed: 70
Added: 27
Removed: 27