Java ArrayBlockingQueue

Neste tutorial, vamos aprender a classe ArrayBlockingQueue e seus métodos com a ajuda de exemplos.

A classe ArrayBlockingQueue da Java Collections Framework fornece uma implementação de fila de espera de array usando arrays.

Ele implementaInterface Java BlockingQueue.

Criar ArrayBlockingQueue

Para criar uma fila de espera de array, devemos importar o pacote java.util.concurrent.ArrayBlockingQueue.

Após importar o pacote, você pode usar os seguintes métodos para criar uma fila de espera de array no Java:

ArrayBlockingQueue<Type> animal = new ArrayBlockingQueue<>(int capacidade);

Aqui,

• Tipo - Tipo da fila de espera de array

• capacidade - Tamanho da fila de espera de array

Por exemplo,

//Cria um ArrayBlockingQueue de tamanho5ArrayBlockingQueue de tipo string
ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);
//Cria um ArrayBlockingQueue de tamanho5ArrayBlockingQueue de tipo inteiro
ArrayBlockingQueue<Integer> age = new ArrayBlockingQueue<>(5);

Atenção:Deve fornecer o tamanho do array.

Métodos da ArrayBlockingQueue

A classe ArrayBlockingQueue oferece implementações de todos os métodos da interface BlockingQueue.

Além disso, aprenderemos dois métodos put() e take(), que suportam operações de bloqueio na fila de espera de array.

Essas duas métodos diferenciam a fila de espera de array de outras filas tipicas.

Insere o elemento

• add() - Insere o elemento especificado na fila de espera de array. Se a fila já estiver cheia, lançará uma exceção.

• offer() - Insere o elemento especificado na fila de espera de array. Se a fila já estiver cheia, retorna false.

Por exemplo,

import java.util.concurrent.ArrayBlockingQueue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);
　　　　　　　　//Usando add()
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　//Usando offer()
　　　　　　　　animals.offer("Horse");
　　　　　　　　System.out.println("ArrayBlockingQueue: ");　+　animals);
　　　　}
}

Resultados de saída

ArrayBlockingQueue: [Dog, Cat, Horse]

Acessar elemento

• peek() - Retornar um elemento da frente do ArrayBlockingQueue. Se a fila estiver vazia, retornar null.

• iterator() - Retornar um objeto iterador para acessar os elementos do ArrayBlockingQueue em ordem. Se a fila estiver vazia, lançar exceção. Devemos importar o pacote java.util.Iterator para usá-lo.

Por exemplo,

import java.util.concurrent.ArrayBlockingQueue;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);
　　　　　　　　//Adicionar elemento
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("ArrayBlockingQueue: ");　+　animals);
　　　　　　　　//　Usando peek()
　　　　　　　　String element = animals.peek();
　　　　　　　　System.out.println("Acessar elemento: ");　+　element);
　　　　　　　　//　Usando iterator()
　　　　　　　　Iterator<String> iterate = animals.iterator();
　　　　　　　　System.out.print("Elementos do ArrayBlockingQueue: ");
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Resultados de saída

ArrayBlockingQueue: [Dog, Cat, Horse]
Acessar elemento: Dog
Elementos do ArrayBlockingQueue: Dog, Cat, Horse,

Remover elemento

• remove() - Retornar e remover do ArrayBlockingQueue o elemento especificado. Se a fila estiver vazia, lançar exceção.

• poll() - Retornar e remover do ArrayBlockingQueue o elemento especificado. Se a fila estiver vazia, retornar null.

• clear() - Remover todos os elementos da fila de bloco de array.

Por exemplo,

import java.util.concurrent.ArrayBlockingQueue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("ArrayBlockingQueue: ");　+　animals);
　　　　　　　　//　Usando remove()
　　　　　　　　String element1　= animals.remove();
　　　　　　　　System.out.println("Remover elemento:");
　　　　　　　　System.out.println("Usando remove(): "}　+　element1);
　　　　　　　　//　Usando poll()
　　　　　　　　String element2　= animals.poll();
　　　　　　　　System.out.println("Usando poll(): "}　+　element2);
　　　　　　　　//　Usando clear()
　　　　　　　　animals.clear();
　　　　　　　　System.out.println("Atualizado ArrayBlockingQueue: "}　+　animals);
　　　　}
}

Resultados de saída

ArrayBlockingQueue: [Dog, Cat, Horse]
Remover elemento:
Usando remove(): Dog
Usando poll(): Cat
ArrayBlockingQueue atualizado: []

Métodos put() e take()

Em processos multithreaded, podemos usar put() e take() para bloquear a operação de uma thread, sincronizando-a com outra thread. Esses métodos esperarão até que possam ser executados com sucesso.

Método put()

Para adicionar um elemento ao final da fila de bloqueio de array, podemos usar o método put().

Se a fila de bloqueio de array estiver cheia, ela aguardará até que haja espaço suficiente na fila de bloqueio de array para adicionar elementos.

Por exemplo,

import java.util.concurrent.ArrayBlockingQueue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);
　　　　　　　try {
　　　　　　　　　　　//Adicionar elementos ao animals
　　　　　　　　　　　animals.put("Dog");
　　　　　　　　　　　animals.put("Cat");
　　　　　　　　　　　System.out.println("ArrayBlockingQueue: ");　+　animals);
　　　　　　　　}
　　　　　　　　catch(Exception e) {
　　　　　　　　　　　　System.out.println(e);
　　　　　　　　}
　　　　}
}

Resultados de saída

ArrayBlockingQueue: [Dog, Cat]

Aqui, se o método put() for interrompido durante a espera, pode lançar a exceção InterruptedException. Portanto, devemos incluí-lo no bloco try..catch.

Método take()

Para retornar e remover um elemento da frente da fila de bloqueio de array, podemos usar o método take().

Se a fila de bloqueio de array estiver vazia, ela aguardará até que a fila de bloqueio de array tenha elementos a serem removidos.

Por exemplo,

import java.util.concurrent.ArrayBlockingQueue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);
　　　　　　　try {
　　　　　　　　　　　//Adicionar elementos ao animals
　　　　　　　　　　　animals.put("Dog");
　　　　　　　　　　　animals.put("Cat");
　　　　　　　　　　　System.out.println("ArrayBlockingQueue: ");　+　animals);
　　　　　　　　　　　//Remover um elemento
　　　　　　　　　　　String element = animals.take();
　　　　　　　　　　　System.out.println("Elemento removido: ");　+　element);
　　　　　　　　}
　　　　　　　　catch(Exception e) {
　　　　　　　　　　　　System.out.println(e);
　　　　　　　　}
　　　　}
}

Resultados de saída

ArrayBlockingQueue: [Dog, Cat]
Elemento removido: Dog

Aqui, se o método take() for interrompido durante o processo de espera, ele lançará a exceção InterruptedException. Portanto, devemos encapsulá-lo em um bloco try...catch.

Outros Métodos

Por que usar ArrayBlockingQueue?

ArrayBlockingQueue usa um array como seu armazenamento interno.

É consideradoThread-safeConjunto. Portanto, é geralmente usado em aplicações multithreading.

Suponha que uma thread esteja inserindo elementos na fila enquanto outra thread está removendo elementos da fila.

Agora, se a primeira thread for mais lenta do que a segunda, a fila de bloqueio de array permitirá que a segunda thread aguarde até que a primeira complete sua operação.