Java LinkedBlockingQueue

Neste tutorial, vamos aprender com exemplos a classe LinkedBLockingQueue e seus métodos.

A classe LinkedBlockingQueue do Java Collections Framework usa lista para fornecer implementação de fila de bloqueio.

Ele implementaInterface Java BlockingQueue.

Criar LinkedBlockingQueue

Para criar uma fila de bloqueio de lista, devemos importar o pacote java.util.concurrent.LinkedBlockingQueue.

Aqui está como criamos uma fila de bloqueio de lista em Java:

1.Sem capacidade inicial

LinkedBlockingQueue<Type> animal = new LinkedBlockingQueue<>();

Aqui, a capacidade inicial padrão é2 ³¹ -1.

2.Com capacidade inicial

LinkedBlockingQueue<Type> animal = new LinkedBlockingQueue<>(int capacity);

Aqui,

• Tipo - Tipo da fila de bloqueio de lista

• Capacidade - Tamanho da fila de bloqueio de lista

Por exemplo,

//Criar uma LinkedBlockingQueue de tamanho5LinkedBlockingQueue de tipo string
LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>();5);
//Criar uma LinkedBlockingQueue de tamanho5LinkedBlockingQueue de tipo inteiro
LinkedBlockingQueue<Integer> age = new LinkedBlockingQueue<>();5);

Atenção:Não é necessário fornecer o tamanho da lista.

Métodos da LinkedBlockingQueue

A classe LinkedBlockingQueue fornecidaInterface BlockingQueueImplementação de todos os métodos.

Esses métodos são usados para inserir, acessar e excluir elementos da fila de bloqueio de lista.

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

Essas duas métodos distinguem a fila de bloqueio de lista de outras filas típicas.

Inserir o elemento

• add() - Insere o elemento especificado na fila de bloqueio de lista. Se a fila estiver cheia, lança uma exceção.

• offer() - Insere o elemento especificado na fila de bloqueio de lista. Se a fila estiver cheia, retorna false.

Por exemplo,

import java.util.concurrent.LinkedBlockingQueue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>();5);
　　　　　　　　//　Usar add()
　　　　　　　　animals.add("Cão");
　　　　　　　　animals.add("Gato");
　　　　　　　　//　Usar offer()
　　　　　　　　animals.offer("Horse");
　　　　　　　　System.out.println("LinkedBlockingQueue: ",　+　animals);
　　　　}
}

Resultado de saída

LinkedBlockingQueue: [Cão, Gato, Cavalo]

Acessar o elemento

• peek() - Retorna um elemento da frente da fila de bloqueio de lista. Se a fila estiver vazia, retorna null.

• iterator() - Retorna um objeto iterador para acessar os elementos da fila de bloqueio de lista em ordem. Se a fila estiver vazia, lança uma exceção. Devemos importar o pacote java.util.Iterator para usá-lo.

Por exemplo,

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

Resultado de saída

LinkedBlockingQueue: [Cão, Gato, Cavalo]
Acessar elemento: Cão
Elementos da LinkedBlockingQueue: Cão, Gato, Cavalo,

Remover elemento

• remove() - Retorna e remove o elemento especificado da fila de bloqueio de lista. Se a fila estiver vazia, lança uma exceção.

• poll() - Retorna e remove o elemento especificado da fila de bloqueio de lista. Se a fila estiver vazia, retorna null.

• clear() - Remover todos os elementos da fila de bloqueio de lista.

Por exemplo,

import java.util.concurrent.LinkedBlockingQueue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>();5);
　　　　　　　　animals.add("Cão");
　　　　　　　　animals.add("Gato");
　　　　　　　　animals.add("Cavalo");
　　　　　　　　System.out.println("LinkedBlockingQueue ")　+　animals);
　　　　　　　　//　Usando remove()
　　　　　　　　String elemento1　= animals.remove();
　　　　　　　　System.out.println("Remover elemento:")
　　　　　　　　System.out.println("Usando remove(): ")　+　elemento1);
　　　　　　　　//　Usando poll()
　　　　　　　　String elemento2　= animals.poll();
　　　　　　　　System.out.println("Usando poll(): ")　+　elemento2);
　　　　　　　　//　Usando clear()
　　　　　　　　animals.clear();
　　　　　　　　System.out.println("LinkedBlockingQueue atualizado ")　+　animals);
　　　　}
}

Resultado de saída

LinkedBlockingQueue: [Cão, Gato, Cavalo]
Remover elemento:
Usando remove(): Cão
Usando poll(): Gato
LinkedBlockingQueue: []

Métodos put() e take()

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

Método put()

Para inserir o elemento especificado no final da fila de bloco de lista, usamos o método put().

Se a fila de bloco de lista estiver cheia, ela esperará até que haja espaço suficiente na fila de bloco de lista para inserir o elemento.

Por exemplo,

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

Resultado de saída

LinkedBlockingQueue: [Cão, Gato]

Aqui, se for interrompido enquanto está esperando, o método put() pode lançar uma exceção InterruptedException. Portanto, devemos incluí-lo emNo bloco try..catch.

Método take()

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

Se a fila de bloco de lista estiver vazia, ela esperará até que a fila de bloco de lista tenha o elemento a ser removido.

Por exemplo,

import java.util.concurrent.LinkedBlockingQueue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>();5);
　　　　　　　try {
　　　　　　　　　　　//Adicionar elementos ao animals
　　　　　　　　　　　animals.put("Cão");
　　　　　　　　　　　animals.put("Gato");
　　　　　　　　　　　System.out.println("LinkedBlockingQueue: ",　+　animals);
　　　　　　　　　　　//Remover um elemento
　　　　　　　　　　　String element = animals.take();
　　　　　　　　　　　System.out.println("Remover elemento: ",　+　element);
　　　　　　　　　　　System.out.println("Nova LinkedBlockingQueue: ",　+　animals);
　　　　　　　　}
　　　　　　　　catch(Exception e) {
　　　　　　　　　　　　System.out.println(e);
　　　　　　　　}
　　　　}
}

Resultado de saída

LinkedBlockingQueue: [Cão, Gato]
Remover elemento: [Cão]
Nova LinkedBlockingQueue: [Gato]

Aqui, se for interrompido enquanto está esperando, o método take() lançará uma exceção InterruptedException. Portanto, devemos encerrá-lo em um bloco try...catch.

Outros métodos

Por que usar LinkedBlockingQueue?

É consideradoThread-safeConjuntos. Portanto, é frequentemente usado em aplicações multithread.

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 que a segunda, a fila de bloqueio de lista permite que a segunda thread aguarde até que a primeira complete sua operação.