Concorrenza Java - Interfaccia BlockingQueue

Un'interfaccia java.util.concurrent.BlockingQueue è una sottointerfaccia dell'interfaccia Queue e supporta inoltre operazioni come l'attesa che la coda diventi non vuota prima di recuperare un elemento e attendere che lo spazio diventi disponibile nella coda prima di memorizzare un elemento .

Metodi BlockingQueue

Sr.No.	Metodo e descrizione
1	boolean add(E e) Inserisce l'elemento specificato in questa coda se è possibile farlo immediatamente senza violare le limitazioni di capacità, restituendo true in caso di esito positivo e generando un'eccezione IllegalStateException se non è attualmente disponibile spazio.
2	boolean contains(Object o) Restituisce vero se questa coda contiene l'elemento specificato.
3	int drainTo(Collection<? super E> c) Rimuove tutti gli elementi disponibili da questa coda e li aggiunge alla raccolta data.
4	int drainTo(Collection<? super E> c, int maxElements) Rimuove al massimo il numero dato di elementi disponibili da questa coda e li aggiunge alla raccolta data.
5	boolean offer(E e) Inserisce l'elemento specificato in questa coda se è possibile farlo immediatamente senza violare le limitazioni di capacità, restituendo true in caso di successo e false se non è attualmente disponibile spazio.
6	boolean offer(E e, long timeout, TimeUnit unit) Inserisce l'elemento specificato in questa coda, attendendo fino al tempo di attesa specificato, se necessario, affinché lo spazio diventi disponibile.
7	E poll(long timeout, TimeUnit unit) Recupera e rimuove la testata di questa coda, aspettando fino al tempo di attesa specificato, se necessario, che un elemento diventi disponibile.
8	void put(E e) Inserisce l'elemento specificato in questa coda, aspettando se necessario che lo spazio diventi disponibile.
9	int remainingCapacity() Restituisce il numero di elementi aggiuntivi che questa coda può idealmente (in assenza di vincoli di memoria o di risorse) accettare senza bloccare, o Integer.MAX_VALUE se non c'è limite intrinseco.
10	boolean remove(Object o) Rimuove una singola istanza dell'elemento specificato da questa coda, se presente.
11	E take() Recupera e rimuove la testa di questa coda, aspettando se necessario fino a quando un elemento non diventa disponibile.

Esempio

Il seguente programma TestThread mostra l'utilizzo dell'interfaccia BlockingQueue in un ambiente basato su thread.

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();
         }
      }
   }
}

Questo produrrà il seguente risultato.

Produzione

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