Java ArrayBlockingQueue

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

O ArrayBlockingQueue A classe da estrutura Java Collections fornece a implementação da fila de bloqueio usando um array.

Ele implementa a interface Java BlockingQueue.

Criando ArrayBlockingQueue

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

Depois de importar o pacote, veja como podemos criar uma fila de bloqueio de array em Java:

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

Aqui,

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

Por exemplo,

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

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

Observação: É obrigatório fornecer o tamanho do array.

Métodos de ArrayBlockingQueue

O ArrayBlockingQueue classe fornece a implementação de todos os métodos no BlockingQueue interface.

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

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

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

Inserir Elementos

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

Por exemplo,

import java.util.concurrent.ArrayBlockingQueue;

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

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

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

Saída

ArrayBlockingQueue: [Dog, Cat, Horse]

Elementos de acesso

peek() - Retorna um elemento da frente da fila de bloqueio do array. Ele retorna null se a fila estiver vazia.
iterator() - Retorna um objeto iterador para acessar sequencialmente os elementos da fila de bloqueio do array. 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.ArrayBlockingQueue;
import java.util.Iterator;

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

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

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

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

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

Saída

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

Remover elementos

remove() - Retorna e remove um elemento especificado da fila de bloqueio de array. Ele lança uma exceção se a fila estiver vazia.
poll() - Retorna e remove um elemento especificado da fila de bloqueio de array. Ele retorna null se a fila estiver vazia.
clear() - Remove todos os elementos da fila de bloqueio do 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);

        // 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 ArrayBlockingQueue: " + animals);
    }
}

Saída

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

Método 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 adicionar um elemento ao final de uma fila de bloqueio de array, podemos usar o put() método.

Se a fila de bloqueio de array estiver cheia, ela espera até que haja espaço na fila de bloqueio de array para adicionar um elemento.

Por exemplo,

import java.util.concurrent.ArrayBlockingQueue;

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

       try {
        // Add elements to animals
           animals.put("Dog");
           animals.put("Cat");
           System.out.println("ArrayBlockingQueue: " + animals);
        }
        catch(Exception e) {
            System.out.println(e);
        }
    }
}

Saída

ArrayBlockingQueue: [Dog, Cat]

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

Método take()

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

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

Por exemplo,

import java.util.concurrent.ArrayBlockingQueue;

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

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

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

Saída

ArrayBlockingQueue: [Dog, Cat]
Removed Element: Dog

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 de array 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 de array.
`toArray()`	Converte a fila de bloqueio de array em um array e o retorna.
`toString()`	Converte a fila de bloqueio de array em string

Por que usar ArrayBlockingQueue?

O ArrayBlockingQueue usa arrays como seu 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 de array pode fazer com que o segundo thread espere até que o primeiro thread conclua suas operações.

Java BlockingQueue Java LinkedBlockingQueue

Java