Java ArrayBlockingQueue

In diesem Tutorial lernen wir die Klasse ArrayBlockingQueue und ihre Methoden anhand von Beispielen kennen.

Der ArrayBlockingQueue -Klasse des Java-Collections-Frameworks stellt die Implementierung der blockierenden Warteschlange mithilfe eines Arrays bereit.

Es implementiert die Java BlockingQueue-Schnittstelle.

ArrayBlockingQueue erstellen

Um eine Array-Blockierungswarteschlange zu erstellen, müssen wir den java.util.concurrent.ArrayBlockingQueue importieren Paket.

Sobald wir das Paket importiert haben, können wir wie folgt eine Array-Blockierungswarteschlange in Java erstellen:

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

Hier,

Typ - der Typ der Array-Sperrwarteschlange
Kapazität - die Größe der Array-Sperrwarteschlange

Zum Beispiel

// 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);

Hinweis: Die Größe des Arrays muss zwingend angegeben werden.

Methoden von ArrayBlockingQueue

Die ArrayBlockingQueue Klasse stellt die Implementierung aller Methoden in BlockingQueue bereit Schnittstelle.

Diese Methoden werden verwendet, um Elemente aus Array-Sperrwarteschlangen einzufügen, darauf zuzugreifen und sie zu löschen.

Außerdem lernen wir zwei Methoden kennen put() und take() die die Sperroperation in der Array-Blocking-Queue unterstützen.

Diese beiden Methoden unterscheiden die Array-Blockierungswarteschlange von anderen typischen Warteschlangen.

Elemente einfügen

add() - Fügt das angegebene Element in die Array-Sperrwarteschlange ein. Es löst eine Ausnahme aus, wenn die Warteschlange voll ist.
offer() - Fügt das angegebene Element in die Array-Sperrwarteschlange ein. Es gibt false zurück wenn die Warteschlange voll ist.

Zum Beispiel

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);
    }
}

Ausgabe

ArrayBlockingQueue: [Dog, Cat, Horse]

Zugriffselemente

peek() - Gibt ein Element von der Vorderseite der Array-Blockierungswarteschlange zurück. Es gibt null zurück wenn die Warteschlange leer ist.
iterator() - Gibt ein Iterator-Objekt zurück, um sequentiell auf Elemente aus der Array-Blockierungswarteschlange zuzugreifen. Es löst eine Ausnahme aus, wenn die Warteschlange leer ist. Wir müssen den java.util.Iterator importieren Paket, um es zu verwenden.

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);

        // 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(", ");
        }
    }
}

Ausgabe

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

Elemente entfernen

remove() - Gibt ein angegebenes Element aus der Array-Blockierungswarteschlange zurück und entfernt es. Es löst eine Ausnahme aus, wenn die Warteschlange leer ist.
poll() - Gibt ein angegebenes Element aus der Array-Blockierungswarteschlange zurück und entfernt es. Es gibt null zurück wenn die Warteschlange leer ist.
clear() - Entfernt alle Elemente aus der Array Blocking Queue.

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);

        // 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);
    }
}

Ausgabe

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

put()- und take()-Methode

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

put()-Methode

Um ein Element am Ende einer Array-Blockierungswarteschlange hinzuzufügen, können wir den put() verwenden Methode.

Wenn die Array-Blockierungswarteschlange voll ist, wartet sie, bis in der Array-Blockierungswarteschlange Platz 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 {
        // Add elements to animals
           animals.put("Dog");
           animals.put("Cat");
           System.out.println("ArrayBlockingQueue: " + animals);
        }
        catch(Exception e) {
            System.out.println(e);
        }
    }
}

Ausgabe

ArrayBlockingQueue: [Dog, Cat]

Hier der put() -Methode kann einen InterruptedException auslösen wenn es beim Warten unterbrochen wird. Daher müssen wir es in ein try..catch einschließen blockieren.

take()-Methode

Um ein Element aus dem Anfang der Array-Blockierungswarteschlange zurückzugeben und zu entfernen, können wir den take() verwenden Methode.

Wenn die Array-Blockierungswarteschlange leer ist, wartet sie, bis es Elemente in der Array-Blockierungswarteschlange gibt, die gelöscht werden sollen.

Zum Beispiel

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);
        }
    }
}

Ausgabe

ArrayBlockingQueue: [Dog, Cat]
Removed Element: Dog

Hier der take() Methode wird ein InterrupedException auslösen wenn es beim Warten unterbrochen wird. Daher müssen wir es in einen try...catch einschließen blockieren.

Andere Methoden

Methoden	Beschreibungen
`contains(element)`	Durchsucht die Array Blocking Queue nach dem angegebenen Element.Wenn das Element gefunden wird, gibt es `true` zurück , wenn nicht, wird `false` zurückgegeben .
`size()`	Gibt die Länge der Blockierungswarteschlange des Arrays zurück.
`toArray()`	Konvertiert die Array-Blockierungswarteschlange in ein Array und gibt es zurück.
`toString()`	Konvertiert die Blockierungswarteschlange des Arrays in einen String

Warum ArrayBlockingQueue verwenden?

Der ArrayBlockingQueue verwendet Arrays als internen Speicher.

Es gilt als threadsicher Sammlung. Daher wird es im Allgemeinen in Multithreading-Anwendungen verwendet.

Angenommen, ein Thread fügt Elemente in die Warteschlange ein und ein anderer Thread entfernt Elemente aus der Warteschlange.

Wenn nun der erste Thread langsamer als der zweite Thread ist, kann die Array-Blockierungswarteschlange den zweiten Thread warten lassen, bis der erste Thread seine Operationen abgeschlossen hat.

Java BlockingQueue Java LinkedBlockingQueue

Java