Java ArrayBlockingQueue

In this tutorial, we will learn about the ArrayBlockingQueue class and its methods with the help of examples.

The ArrayBlockingQueue class of the Java Collections framework provides an implementation of the blocking queue using arrays.

It implementsJava BlockingQueue Schnittstelle.

Create ArrayBlockingQueue

To create an array blocking queue, we must import the java.util.concurrent.ArrayBlockingQueue package.

After importing the package, you can use the following methods to create an array blocking queue in Java:

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

Here,

• Type - The type of the array blocking queue

• capacity - The size of the array blocking queue

Zum Beispiel,

//Create a size of5string type ArrayBlockingQueue
ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);
//Create a size of5integer type ArrayBlockingQueue
ArrayBlockingQueue<Integer> age = new ArrayBlockingQueue<>(5);

Note:The size of the array must be provided.

ArrayBlockingQueue methods

The ArrayBlockingQueue class provides all the implementations of the methods in the BlockingQueue interface.

In addition, we will learn two methods put() and take(), which support blocking operations in the array blocking queue.

These two methods distinguish the array blocking queue from other typical queues.

Insert element

• add() - Insert the specified element into the array blocking queue. If the queue is full, it will throw an exception.

• offer() - Insert the specified element into the array blocking queue. If the queue is full, it returns false.

Zum Beispiel,

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

Ausgaberesultat

ArrayBlockingQueue: [Dog, Cat, Horse]

Element aufrufen

• peek() - Geben Sie ein Element vom Anfang der ArrayBlockingQueue zurück. Wenn die Queue leer ist, wird null zurückgegeben.

• iterator() - Geben Sie ein Iterator-Objekt zurück, um die Elemente der ArrayBlockingQueue in der Reihenfolge zu durchsuchen. Wenn die Queue leer ist, wird eine Ausnahme ausgelöst. Wir müssen das Softwarepaket java.util.Iterator importieren, um es verwenden zu können.

Zum Beispiel,

import java.util.concurrent.ArrayBlockingQueue;
import　java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);
　　　　　　　　//Element hinzufügen
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("ArrayBlockingQueue: ");　+　animals);
　　　　　　　　//　Verwenden Sie	peek()
　　　　　　　　String　element　=　animals.peek();
　　　　　　　　System.out.println("Element aufrufen:　"　+　element);
　　　　　　　　//　Verwenden Sie	iterator()
　　　　　　　　Iterator<String>　iterate　=　animals.iterator();
　　　　　　　　System.out.print("ArrayBlockingQueue-Elemente:　");
　　　　　　　　while(iterate.hasNext())　{
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(",	);
　　　　　　　　}
　　　　}
}

Ausgaberesultat

ArrayBlockingQueue: [Dog, Cat, Horse]
Element aufrufen:　Dog
ArrayBlockingQueue-Elemente:　Dog,　Cat,　Horse,

Element löschen

• remove() - Geben Sie das angegebene Element zurück und entfernen Sie es aus der ArrayBlockingQueue. Wenn die Queue leer ist, wird eine Ausnahme ausgelöst.

• poll() - Geben Sie das angegebene Element zurück und entfernen Sie es aus der ArrayBlockingQueue. Wenn die Queue leer ist, wird null zurückgegeben.

• clear() - Entfernen Sie alle Elemente aus der ArrayBlockingQueue.

Zum Beispiel,

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);
　　　　　　　　//　Verwenden Sie	remove()
　　　　　　　　String　element1　=　animals.remove();
　　　　　　　　System.out.println("Element löschen:");
　　　　　　　　System.out.println("Verwenden Sie	remove():	"　+　element1);
　　　　　　　　//　Verwenden Sie	poll()
　　　　　　　　String　element2　=　animals.poll();
　　　　　　　　System.out.println("Verwenden Sie	poll():	"　+　element2);
　　　　　　　　//　Verwenden Sie	clear()
　　　　　　　　animals.clear();
　　　　　　　　System.out.println("Aktualisierte ArrayBlockingQueue:	"　+　animals);
　　　　}
}

Ausgaberesultat

ArrayBlockingQueue: [Dog, Cat, Horse]
Element löschen:
Verwenden Sie remove(): Dog
Verwenden Sie poll(): Cat
Aktualisierte ArrayBlockingQueue: []

put() und take() Methoden

In einem Mehr-Prozess-Thread können wir put() und take() verwenden, um die Operation eines Threads zu blockieren und ihn mit einem anderen Thread zu synchronisieren. Diese Methoden warten, bis sie erfolgreich ausgeführt werden können.

put() Methode

Um ein Element an das Ende der ArrayBlockingQueue anzuhängen, kann der put()-Methodenaufruf verwendet werden.

Wenn die ArrayBlockingQueue voll ist, wartet sie, bis genügend Platz in der ArrayBlockingQueue vorhanden ist, um ein Element hinzuzufügen.

Zum Beispiel,

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

Ausgaberesultat

ArrayBlockingQueue: [Dog, Cat]

Hier wird eine InterruptedException ausgelöst, wenn der put()-Methodenaufruf unterbrochen wird, während er auf den Abschluss wartet. Daher müssen wir ihn in einem try..catch-Block verpacken.

take() Methode

Um ein Element von der Vorderseite der ArrayBlockingQueue zurückzugeben und zu löschen, können wir den take()-Methodenaufruf verwenden.

Wenn die ArrayBlockingQueue leer ist, wartet sie, bis ein zu löschendes Element in der ArrayBlockingQueue vorhanden ist.

Zum Beispiel,

import java.util.concurrent.ArrayBlockingQueue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);
　　　　　　　try {
　　　　　　　　　　　//Elemente zu animals hinzufügen
　　　　　　　　　　　animals.put("Dog");
　　　　　　　　　　　animals.put("Cat");
　　　　　　　　　　　System.out.println("ArrayBlockingQueue: ");　+　animals);
　　　　　　　　　　　//Ein Element löschen
　　　　　　　　　　　String element = animals.take();
　　　　　　　　　　　System.out.println("Gelöschtes Element: ");　+　element);
　　　　　　　　}
　　　　　　　　catch(Exception e) {
　　　　　　　　　　　　System.out.println(e);
　　　　　　　　}
　　　　}
}

Ausgaberesultat

ArrayBlockingQueue: [Dog, Cat]
Gelöschtes Element: Dog

Hier wird eine InterruptedException ausgelöst, wenn der take()-Methodenaufruf unterbrochen wird, während er auf den Abschluss wartet. Daher müssen wir ihn in einem try…catch-Block verpacken.

Andere Methoden

Warum sollte man ArrayBlockingQueue verwenden?

ArrayBlockingQueue verwendet ein Array als internes Speichermedium.

Es wird alsThread-sicherKollektionen. Daher wird sie häufig in Multithreading-Anwendungen verwendet.

Angenommen, ein Thread fügt Elemente in die Warteschlange ein, während ein anderer Thread Elemente aus der Warteschlange löscht.

Wenn der erste Thread langsamer als der zweite Thread ist, kann die ArrayBlockingQueue den zweiten Thread warten lassen, bis der erste Thread seine Operation abgeschlossen hat.