Java LinkedBlockingQueue
Java LinkedBlockingQueue
In diesem Tutorial lernen wir die Klasse LinkedBLockingQueue und ihre Methoden anhand von Beispielen kennen.
Der LinkedBlockingQueue Klasse von Java Collections Framework bietet die Implementierung der blockierenden Warteschlange mithilfe einer verketteten Liste.
Es implementiert die Java BlockingQueue-Schnittstelle.
LinkedBlockingQueue erstellen
Um eine verknüpfte Sperrwarteschlange zu erstellen, müssen wir den java.util.concurrent.LinkedBlockingQueue importieren Paket.
So können wir eine verknüpfte Sperrwarteschlange in Java erstellen:
1. Ohne die Anfangskapazität
LinkedBlockingQueue<Type> animal = new LinkedBlockingQueue<>();
Hier beträgt die standardmäßige Anfangskapazität 2 31 -1.
2. Mit der Anfangskapazität
LinkedBlockingQueue<Type> animal = new LinkedBlockingQueue<>(int capacity);
Hier,
- Typ - der Typ der verknüpften Sperrwarteschlange
- Kapazität - die Größe der verknüpften Sperrwarteschlange
Zum Beispiel
// 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);
Hinweis: Es ist nicht zwingend erforderlich, die Größe der verknüpften Liste anzugeben.
Methoden von LinkedBlockingQueue
Die LinkedBlockingQueue -Klasse stellt die Implementierung aller Methoden in der BlockingQueue-Schnittstelle bereit.
Diese Methoden werden verwendet, um Elemente aus verknüpften Sperrwarteschlangen einzufügen, darauf zuzugreifen und sie zu löschen.
Außerdem lernen wir zwei Methoden kennen put() und take() die den Sperrvorgang in der verknüpften Sperrwarteschlange unterstützen.
Diese beiden Methoden unterscheiden die verknüpfte Sperrwarteschlange von anderen typischen Warteschlangen.
Elemente einfügen
add()- Fügt ein bestimmtes Element in die verknüpfte Sperrwarteschlange ein. Es löst eine Ausnahme aus, wenn die Warteschlange voll ist.offer()- Fügt ein bestimmtes Element in die verknüpfte Sperrwarteschlange ein. Es gibtfalsezurück wenn die Warteschlange voll ist.
Zum Beispiel
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);
}
}
Ausgabe
LinkedBlockingQueue: [Dog, Cat, Horse]
Zugriffselemente
peek()- Gibt ein Element von der Vorderseite der verknüpften Sperrwarteschlange zurück. Es gibtnullzurück wenn die Warteschlange leer ist.iterator()– Gibt ein Iteratorobjekt zurück, um sequenziell auf ein Element aus der verknüpften Sperrwarteschlange zuzugreifen. Es löst eine Ausnahme aus, wenn die Warteschlange leer ist. Wir müssen denjava.util.Iteratorimportieren Paket, um es zu verwenden.
Zum Beispiel
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(", ");
}
}
}
Ausgabe
LinkedBlockingQueue: [Dog, Cat, Horse] Accessed Element: Dog LinkedBlockingQueue Elements: Dog, Cat, Horse,
Elemente entfernen
remove()- Gibt ein bestimmtes Element aus der verknüpften Sperrwarteschlange zurück und entfernt es. Es löst eine Ausnahme aus, wenn die Warteschlange leer ist.poll()- Gibt ein bestimmtes Element aus der verknüpften Sperrwarteschlange zurück und entfernt es. Es gibtnullzurück wenn die Warteschlange leer ist.clear()- Entfernt alle Elemente aus der verknüpften Sperrwarteschlange.
Zum Beispiel
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);
}
}
Ausgabe
LinkedBlockingQueue: [Dog, Cat, Horse] Removed Elements: Using remove(): Dog Using poll(): Cat Updated LinkedBlockingQueue: []
put()- und take()-Methoden
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 das angegebene Element am Ende einer verknüpften Sperrwarteschlange einzufügen, verwenden wir den put() Methode.
Wenn die verknüpfte Sperrwarteschlange voll ist, wartet sie, bis in der verknüpften Sperrwarteschlange Platz ist, um das Element einzufügen.
Zum Beispiel
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);
}
}
}
Ausgabe
LinkedBlockingQueue: [Dog, Cat]
Hier der put() -Methode kann einen InterruptedException auslösen wenn es beim Warten unterbrochen wird. Daher müssen wir es in einen try..catch-Block einschließen.
take()-Methode
Um ein Element von der Vorderseite der verknüpften Sperrwarteschlange zurückzugeben und zu entfernen, können wir den take() verwenden Methode.
Wenn die verknüpfte Sperrwarteschlange leer ist, wird gewartet, bis Elemente in der verknüpften Sperrwarteschlange gelöscht werden müssen.
Zum Beispiel
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);
}
}
}
Ausgabe
LinkedBlockingQueue: [Dog, Cat] Removed Element: Dog New LinkedBlockingQueue: [Cat]
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 verknüpfte Sperrwarteschlange 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 verknüpften Sperrwarteschlange zurück. |
toArray() | Konvertiert die verknüpfte Sperrwarteschlange in ein Array und gibt das Array zurück. |
toString() | Konvertiert die verknüpfte Sperrwarteschlange in einen String |
Warum LinkedBlockingQueue verwenden?
Der LinkedBlockingQueue verwendet verknüpfte Listen 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 verknüpfte Sperrwarteschlange den zweiten Thread so lange warten lassen, bis der erste Thread seine Operationen abgeschlossen hat.
Java