Java LinkedBlockingQueue

Neste tutorial, aprenderemos sobre a classe LinkedBLockingQueue e seus métodos com a ajuda de exemplos.

O LinkedBlockingQueue classe do Java Collections framework fornece a implementação da fila de bloqueio usando uma lista vinculada.

Ele implementa a interface Java BlockingQueue.

Criando LinkedBlockingQueue

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

Aqui está como podemos criar uma fila de bloqueio vinculada em Java:

1. Sem a capacidade inicial

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

Aqui a capacidade inicial padrão será 2³¹ -1.

2. Com a capacidade inicial

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

Aqui,

Tipo - o tipo da fila de bloqueio vinculada
capacidade - o tamanho da fila de bloqueio vinculada

Por exemplo,

// Creating String type LinkedBlockingQueue with size 5
LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);

// Creating Integer type LinkedBlockingQueue with size 5
LinkedBlockingQueue<Integer> age = new LinkedBlockingQueue<>(5);

Observação: Não é obrigatório fornecer o tamanho da lista vinculada.

Métodos de LinkedBlockingQueue

O LinkedBlockingQueue A classe fornece a implementação de todos os métodos na interface BlockingQueue.

Esses métodos são usados para inserir, acessar e excluir elementos de filas de bloqueio vinculadas.

Além disso, aprenderemos sobre dois métodos put() e take() que suportam a operação de bloqueio na fila de bloqueio vinculada.

Esses dois métodos distinguem a fila de bloqueio vinculada de outras filas típicas.

Inserir Elementos

add() - Insere um elemento especificado na fila de bloqueio vinculada. Ele lança uma exceção se a fila estiver cheia.
offer() - Insere um elemento especificado na fila de bloqueio vinculada. Ele retorna false se a fila estiver cheia.

Por exemplo,

import java.util.concurrent.LinkedBlockingQueue;

class Main {
    public static void main(String[] args) {
        LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);

        // Using add()
        animals.add("Dog");
        animals.add("Cat");

        // Using offer()
        animals.offer("Horse");
        System.out.println("LinkedBlockingQueue: " + animals);
    }
}

Saída

LinkedBlockingQueue: [Dog, Cat, Horse]

Elementos de acesso

peek() - Retorna um elemento da frente da fila de bloqueio vinculada. Ele retorna null se a fila estiver vazia.
iterator() - Retorna um objeto iterador para acessar sequencialmente um elemento da fila de bloqueio vinculada. Ele lança uma exceção se a fila estiver vazia. Devemos importar o java.util.Iterator pacote 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);

        // Add elements
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("LinkedBlockingQueue: " + animals);

        // Using peek()
        String element = animals.peek();
        System.out.println("Accessed Element: " + element);

        // Using iterator()
        Iterator<String> iterate = animals.iterator();
        System.out.print("LinkedBlockingQueue Elements: ");

        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }
    }
}

Saída

LinkedBlockingQueue: [Dog, Cat, Horse]
Accessed Element: Dog
LinkedBlockingQueue Elements: Dog, Cat, Horse,

Remover elementos

remove() - Retorna e remove um elemento especificado da fila de bloqueio vinculada. Ele lança uma exceção se a fila estiver vazia.
poll() - Retorna e remove um elemento especificado da fila de bloqueio vinculada. Ele retorna null se a fila estiver vazia.
clear() - Remove todos os elementos da fila de bloqueio vinculada.

Por exemplo,

import java.util.concurrent.LinkedBlockingQueue;

class Main {
    public static void main(String[] args) {
        LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);

        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("LinkedBlockingQueue " + animals);

        // Using remove()
        String element1 = animals.remove();
        System.out.println("Removed Element:");
        System.out.println("Using remove(): " + element1);

        // Using poll()
        String element2 = animals.poll();
        System.out.println("Using poll(): " + element2);

        // Using clear()
        animals.clear();
        System.out.println("Updated LinkedBlockingQueue " + animals);
    }
}

Saída

LinkedBlockingQueue: [Dog, Cat, Horse]
Removed Elements:
Using remove(): Dog
Using poll(): Cat
Updated LinkedBlockingQueue: []

Métodos put() e take()

Em processos multithreading, podemos usar put() e take() para bloquear a operação de um thread para sincronizá-lo com outro thread. Esses métodos aguardarão até que possam ser executados com sucesso.

Método put()

Para inserir o elemento especificado no final de uma fila de bloqueio vinculada, usamos o put() método.

Se a fila de bloqueio vinculada estiver cheia, ela aguardará até que haja espaço na fila de bloqueio vinculada 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 {
        // Add elements to animals
           animals.put("Dog");
           animals.put("Cat");
           System.out.println("LinkedBlockingQueue: " + animals);
        }
        catch(Exception e) {
            System.out.println(e);
        }
    }
}

Saída

LinkedBlockingQueue: [Dog, Cat]

Aqui, o put() pode lançar um InterruptedException se for interrompido enquanto espera. Portanto, devemos colocá-lo dentro de um bloco try..catch.

Método take()

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

Se a fila de bloqueio vinculada estiver vazia, ela aguardará até que haja elementos na fila de bloqueio vinculada a serem excluídos.

Por exemplo,

import java.util.concurrent.LinkedBlockingQueue;

class Main {
    public static void main(String[] args) {
        LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);

       try {
           //Add elements to animals
           animals.put("Dog");
           animals.put("Cat");
           System.out.println("LinkedBlockingQueue: " + animals);

           // Remove an element
           String element = animals.take();
           System.out.println("Removed Element: " + element);
           System.out.println("New LinkedBlockingQueue: " + animals);
        }
        catch(Exception e) {
            System.out.println(e);
        }
    }
}

Saída

LinkedBlockingQueue: [Dog, Cat]
Removed Element: Dog
New LinkedBlockingQueue: [Cat]

Aqui, o take() método lançará um InterrupedException se for interrompido enquanto espera. Portanto, devemos colocá-lo dentro de um try...catch quadra.

Outros métodos

Métodos	Descrições
`contains(element)`	Pesquisa a fila de bloqueio vinculada para o elemento especificado. Se o elemento for encontrado, ele retornará `true` , caso contrário, retornará `false` .
`size()`	Retorna o comprimento da fila de bloqueio vinculada.
`toArray()`	Converte a fila de bloqueio vinculada em uma matriz e retorna a matriz.
`toString()`	Converte a fila de bloqueio vinculada em string

Por que usar LinkedBlockingQueue?

O LinkedBlockingQueue usa listas vinculadas como armazenamento interno.

É considerado um segmento seguro coleção. Por isso, é geralmente usado em aplicativos multi-threading.

Suponha que uma thread esteja inserindo elementos na fila e outra thread esteja removendo elementos da fila.

Agora, se o primeiro thread for mais lento que o segundo thread, a fila de bloqueio vinculada poderá fazer com que o segundo thread aguarde até que o primeiro thread conclua suas operações.

Java ArrayBlockingQueue Interface de mapa Java

Java