Simultaneidade Java - Interface BlockingQueue

Uma interface java.util.concurrent.BlockingQueue é uma subinterface da interface Queue e, adicionalmente, suporta operações como esperar que a fila se torne vazia antes de recuperar um elemento e esperar que o espaço fique disponível na fila antes de armazenar um elemento .

Métodos BlockingQueue

Sr. Não.	Método e Descrição
1	boolean add(E e) Insere o elemento especificado nesta fila se for possível fazê-lo imediatamente sem violar as restrições de capacidade, retornando true em caso de sucesso e lançando uma IllegalStateException se nenhum espaço estiver disponível no momento.
2	boolean contains(Object o) Retorna verdadeiro se esta fila contém o elemento especificado.
3	int drainTo(Collection<? super E> c) Remove todos os elementos disponíveis desta fila e os adiciona à coleção fornecida.
4	int drainTo(Collection<? super E> c, int maxElements) Remove no máximo o número fornecido de elementos disponíveis desta fila e os adiciona à coleção fornecida.
5	boolean offer(E e) Insere o elemento especificado nesta fila se for possível fazê-lo imediatamente sem violar as restrições de capacidade, retornando verdadeiro em caso de sucesso e falso se nenhum espaço estiver disponível.
6	boolean offer(E e, long timeout, TimeUnit unit) Insere o elemento especificado nesta fila, aguardando o tempo de espera especificado, se necessário, para que o espaço fique disponível.
7	E poll(long timeout, TimeUnit unit) Recupera e remove o início desta fila, aguardando até o tempo de espera especificado, se necessário, para que um elemento fique disponível.
8	void put(E e) Insere o elemento especificado nesta fila, aguardando, se necessário, que o espaço se torne disponível.
9	int remainingCapacity() Retorna o número de elementos adicionais que esta fila pode idealmente (na ausência de restrições de memória ou recursos) aceitar sem bloqueio, ou Integer.MAX_VALUE se não houver limite intrínseco.
10	boolean remove(Object o) Remove uma única instância do elemento especificado desta fila, se estiver presente.
11	E take() Recupera e remove o início desta fila, aguardando se necessário até que um elemento esteja disponível.

Exemplo

O programa TestThread a seguir mostra o uso da interface BlockingQueue em um ambiente baseado em 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();
         }
      }
   }
}

Isso produzirá o seguinte resultado.

Resultado

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