Java ArrayBlockingQueue

In questo tutorial, impareremo la classe ArrayBlockingQueue e i suoi metodi con l'aiuto di esempi.

La classe ArrayBlockingQueue del framework Java Collections fornisce un'implementazione della coda bloccata di array utilizzando array.

ImplementaInterfaccia Java BlockingQueue.

Creazione di ArrayBlockingQueue

Per creare una coda bloccata di array, dobbiamo importare il pacchetto java.util.concurrent.ArrayBlockingQueue.

Dopo aver importato il pacchetto, è possibile utilizzare i seguenti metodi per creare una coda bloccata di array in Java:

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

Ecco:

• Type - Il tipo della coda bloccata di array

• capacity - La dimensione della coda bloccata di array

Ad esempio,

//Crea una ArrayBlockingQueue di stringhe di dimensione 5
ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);
//Crea una ArrayBlockingQueue di interi di dimensione 5
ArrayBlockingQueue<Integer> age = new ArrayBlockingQueue<>(5);

Attenzione:Deve essere fornita la dimensione dell'array.

Metodi di ArrayBlockingQueue

La classe ArrayBlockingQueue implementa tutti i metodi dell'interfaccia BlockingQueue.

Inoltre, impareremo due metodi put() e take(), che supportano operazioni bloccate nella coda bloccata di array.

Questi metodi distinguono la coda bloccata di array da altre code tipiche.

Inserimento degli elementi

• add() - Inserisce l'elemento specificato nella coda bloccata di array. Se la coda è piena, lancia un'eccezione.

• offer() - Inserisce l'elemento specificato nella coda bloccata di array. Se la coda è piena, restituisce false.

Ad esempio,

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

Risultato di output

ArrayBlockingQueue: [Dog, Cat, Horse]

Accesso agli elementi

• peek() - Restituisce un elemento dalla testa della coda bloccata di array. Se la coda è vuota, restituisce null.

• iterator() - Restituire un oggetto iteratore per accedere in ordine agli elementi dell'ArrayBlockingQueue. Se la coda è vuota, sollevare un'eccezione. Dobbiamo importare il pacchetto java.util.Iterator per utilizzarlo.

Ad esempio,

import java.util.concurrent.ArrayBlockingQueue;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);
　　　　　　　　// Aggiungere elementi
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("ArrayBlockingQueue: " + animals);
　　　　　　　　// Utilizzo di peek()
　　　　　　　　String element = animals.peek();
　　　　　　　　System.out.println("Accesso all'elemento: " + element);
　　　　　　　　// Utilizzo di iterator()
　　　　　　　　Iterator<String> iterate = animals.iterator();
　　　　　　　　System.out.print("Elementi ArrayBlockingQueue: ");
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Risultato di output

ArrayBlockingQueue: [Dog, Cat, Horse]
Accesso all'elemento: Dog
Elementi ArrayBlockingQueue: Dog, Cat, Horse,

Eliminare l'elemento

• remove() - Restituire e eliminare l'elemento specificato dall'ArrayBlockingQueue. Se la coda è vuota, sollevare un'eccezione.

• poll() - Restituire e eliminare l'elemento specificato dall'ArrayBlockingQueue. Se la coda è vuota, restituire null.

• clear() - Eliminare tutti gli elementi dall'ArrayBlockingQueue.

Ad esempio,

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);
　　　　　　　　// Utilizzo di remove()
　　　　　　　　String element1 = animals.remove();
　　　　　　　　System.out.println("Eliminare l'elemento:");
　　　　　　　　System.out.println("Utilizzo di remove(): " + element1);
　　　　　　　　// Utilizzo di poll()
　　　　　　　　String element2 = animals.poll();
　　　　　　　　System.out.println("Utilizzo di poll(): " + element2);
　　　　　　　　// Utilizzo di clear()
　　　　　　　　animals.clear();
　　　　　　　　System.out.println("Aggiornato ArrayBlockingQueue: " + animals);
　　　　}
}

Risultato di output

ArrayBlockingQueue: [Dog, Cat, Horse]
Eliminare l'elemento:
Usando remove(): Dog
Usando poll(): Cat
ArrayBlockingQueue aggiornato: []

Metodi put() e take()

Nel processo multithreading, possiamo utilizzare put() e take() per bloccare l'operazione di una thread, sincronizzandola con un altro thread. Questi metodi attendono fino a quando non possono eseguire con successo.

Metodo put()

Per aggiungere un elemento alla fine della coda bloccata dell'array, possiamo utilizzare il metodo put().

Se la coda bloccata dell'array è piena, attende fino a quando la coda bloccata dell'array ha abbastanza spazio per aggiungere l'elemento.

Ad esempio,

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

Risultato di output

ArrayBlockingQueue: [Dog, Cat]

In questo caso, se il metodo put() viene interrotto durante l'attesa, potrebbe lanciare l'eccezione InterruptedException. Pertanto, dobbiamo includerlo nel blocco try..catch.

Metodo take()

Per restituire e eliminare un elemento dalla coda bloccata dell'array, possiamo utilizzare il metodo take().

Se la coda bloccata dell'array è vuota, attende fino a quando la coda bloccata dell'array ha l'elemento da eliminare.

Ad esempio,

import java.util.concurrent.ArrayBlockingQueue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);
　　　　　　　try {
　　　　　　　　　　　//Aggiungere elementi alla coda animals
　　　　　　　　　　　animals.put("Dog");
　　　　　　　　　　　animals.put("Cat");
　　　　　　　　　　　System.out.println("ArrayBlockingQueue: " + animals);
　　　　　　　　　　　//Eliminare un elemento
　　　　　　　　　　　String element = animals.take();
　　　　　　　　　　　System.out.println("Elemento eliminato: " + element);
　　　　　　　　}
　　　　　　　　catch(Exception e) {
　　　　　　　　　　　　System.out.println(e);
　　　　　　　　}
　　　　}
}

Risultato di output

ArrayBlockingQueue: [Dog, Cat]
Elemento eliminato: Dog

In questo caso, se il metodo take() viene interrotto durante l'attesa, lancia l'eccezione InterruptedException. Pertanto, dobbiamo avvolgerlo in un blocco try...catch.

Altri metodi

Perché utilizzare ArrayBlockingQueue?

ArrayBlockingQueue utilizza un array come suo magazzino interno.

Considerato cheThread-safeSet. Pertanto, viene utilizzato spesso nelle applicazioni multithreading.

Supponiamo che un thread stia inserendo elementi nella coda e un altro thread stia rimuovendo elementi dalla coda.

Ora, se il primo thread è più lento del secondo thread, la coda bloccata da array può far aspettare il secondo thread fino a quando il primo thread ha completato la sua operazione.