Java LinkedBlockingQueue

In diesem Tutorial werden wir anhand von Beispielen die Klasse LinkedBLockingQueue und ihre Methoden lernen.

Java Collections框架的LinkedBlockingQueue类使用链表提供阻塞队列实现。

它实现了Java BlockingQueue Schnittstelle.

创建LinkedBlockingQueue

为了创建链表阻塞队列，我们必须导入java.util.concurrent.LinkedBlockingQueue包。

这是我们如何在Java中创建链表阻塞队列的方法：

1.无初始容量

LinkedBlockingQueue<Type>　animal　=　new　LinkedBlockingQueue<>();

在此，默认初始容量为2 ³¹ -1.

2.具有初始容量

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

这里，

• Type - 链表阻塞队列的类型

• capacity - 链表阻塞队列的大小

Beispielsweise,

//创建大小为5的字符串类型LinkedBlockingQueue
LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
//创建大小为5的整数类型LinkedBlockingQueue
LinkedBlockingQueue<Integer>　age　=　new　LinkedBlockingQueue<>(5);

注意：并不是必须提供链表的大小。

LinkedBlockingQueue的方法

LinkedBlockingQueue类提供的BlockingQueue的接口所有方法的实现。

这些方法用于从链接的阻塞队列中插入，访问和删除元素。

此外，我们还将学习两种方法put()，take()，它们支持链表阻塞队列中的阻塞操作。

这两种方法将链表阻塞队列与其他典型队列区分开来。

插入元素

• add() - 将指定的元素插入到链表阻塞队列中。如果队列已满，它将抛出异常。

• offer() - 将指定的元素插入到链表阻塞队列中。如果队列已满，则返回false。

Beispielsweise,

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

Ausgabeergebnis

LinkedBlockingQueue: [Dog, Cat, Horse]

访问元素

• peek() - 从链表阻塞队列的前面返回一个元素。如果队列为空，则返回null。

• iterator() - 返回一个迭代器对象，以按顺序访问链表阻塞队列中的元素。如果队列为空，则抛出异常。我们必须导入java.util.Iterator软件包才能使用它。

Beispielsweise,

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

Ausgabeergebnis

LinkedBlockingQueue: [Dog, Cat, Horse]
Element zugreifen: Dog
LinkedBlockingQueue-Elemente: Dog, Cat, Horse,

Element löschen

• remove() - Gibt das angegebene Element zurück und löscht es aus der LinkedListenblockqueue. Wenn die Queue leer ist, wird eine Ausnahme ausgelöst.

• poll() - Gibt das angegebene Element zurück und löscht es aus der LinkedListenblockqueue. Wenn die Queue leer ist, wird null zurückgegeben.

• clear() - Alle Elemente aus der LinkedListenblockqueue löschen.

Beispielsweise,

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

Ausgabeergebnis

LinkedBlockingQueue: [Dog, Cat, Horse]
Element löschen:
Verwendung von remove(): Dog
Verwendung von poll(): Cat
Aktualisierte LinkedBlockingQueue: []

put() und take() Methoden

Im Mehr线程-Prozess können wir die Methoden put() und take() verwenden, um eine Synchronisation zwischen zwei Threads zu erreichen. Diese Methoden warten, bis sie erfolgreich ausgeführt werden können.

put() Methode

Um ein bestimmtes Element an das Ende der LinkedListBlockingQueue einzufügen, verwenden wir die Methode put().

Wenn die LinkedListBlockingQueue voll ist, wartet sie, bis im LinkedListBlockingQueue ausreichend Platz für das Einfügen eines Elements vorhanden ist.

Beispielsweise,

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

Ausgabeergebnis

LinkedBlockingQueue: [Hund, Katze]

Hier wird eine InterruptedException ausgelöst, wenn die Methode put() während der Wartezeit unterbrochen wird. Daher müssen wir sie in einen try...catch-Block einschließen.Im try..catch-Block.

take() Methode

Um ein Element von vorne zurückzugeben und zu löschen, können wir die Methode take() verwenden.

Wenn die LinkedListBlockingQueue leer ist, wartet sie, bis im LinkedListBlockingQueue ein zu löschendes Element vorhanden ist.

Beispielsweise,

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

Ausgabeergebnis

LinkedBlockingQueue: [Hund, Katze]
Element löschen: [Hund]
Neue LinkedBlockingQueue: [Katze]

Hier wird eine InterruptedException ausgelöst, wenn die Methode take() während der Wartezeit unterbrochen wird. Daher müssen wir sie in einem try...catch-Block schließen.

Andere Methoden

Warum sollte man LinkedBlockingQueue verwenden?

Es wird alsThread-sicherKollektionen. Daher wird sie oft in Multithreading-Anwendungen verwendet.

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

Wenn der erste Thread langsamer als der zweite Thread ist, kann die LinkedList BlockingQueue den zweiten Thread bis zur Abwicklung der Operationen des ersten Threads warten lassen.