Java LinkedBlockingQueue meistern: Umfassender Leitfaden & Beispiele

Java LinkedBlockingQueue

Erkunden Sie die LinkedBlockingQueue-Klasse, ihre Kernmethoden und reale Beispiele für thread-sicheres Queueing in Java.

Die LinkedBlockingQueue-Klasse, Teil von Javas java.util.concurrent-Paket, implementiert eine blockierende Queue, die von einer verketteten Liste unterstützt wird. Sie entspricht dem BlockingQueue-Interface und bietet eine robuste, thread-sichere Struktur für konkurrierende Producer-Consumer-Szenarien.

---

LinkedBlockingQueue erstellen

Um diese Queue zu nutzen, importieren Sie java.util.concurrent.LinkedBlockingQueue:

import java.util.concurrent.LinkedBlockingQueue;

1. Ohne initiale Kapazität

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

Die Standardkapazität beträgt Integer.MAX_VALUE (2³¹–1), was die Queue effektiv ungebunden macht.

2. Mit angegebener Kapazität

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

• Type – der Elementtyp (z. B. String, Integer)
• capacity – maximale Anzahl Elemente, die die Queue halten kann

Beispiel:

// String-Queue mit Kapazität 5 LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5); // Integer-Queue mit Kapazität 5 LinkedBlockingQueue<Integer> ages = new LinkedBlockingQueue<>(5);

Hinweis: Kapazität ist optional; weglassen erstellt ungebundene Queue.

---

Wichtige Methoden von LinkedBlockingQueue

Die Klasse implementiert alle BlockingQueue-Methoden für Einfügen, Abrufen und Entfernen. Zwei Methoden – put() und take() – bieten blockierendes Verhalten, das diese Queue von Standard-Queues unterscheidet.

Elemente einfügen

• add(E e) – Fügt Element hinzu, wirft Exception falls Queue voll.
• offer(E e) – Fügt Element hinzu, gibt false zurück falls Queue voll.

Beispiel:

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

Ausgabe

LinkedBlockingQueue: [Dog, Cat, Horse]

Auf Elemente zugreifen

• peek() – Ruft Head ab ohne zu entfernen; gibt null falls leer.
• iterator() – Liefert fail-safe Iterator über die Queue. Importieren Sie java.util.Iterator zur Nutzung.

Beispiel:

import java.util.concurrent.LinkedBlockingQueue; import java.util.Iterator; public 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); String head = animals.peek(); System.out.println("Accessed Element: " + head); Iterator<String> it = animals.iterator(); System.out.print("LinkedBlockingQueue Elements: "); while (it.hasNext()) { System.out.print(it.next() + ", "); } } }

Ausgabe

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

Elemente entfernen

• remove() – Entfernt und gibt Head zurück; wirft Exception falls leer.
• poll() – Entfernt und gibt Head zurück; gibt null falls leer.
• clear() – Entfernt alle Elemente.

Beispiel:

import java.util.concurrent.LinkedBlockingQueue; public 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); String removed = animals.remove(); System.out.println("Using remove(): " + removed); String polled = animals.poll(); System.out.println("Using poll(): " + polled); animals.clear(); System.out.println("Updated LinkedBlockingQueue: " + animals); } }

Ausgabe

LinkedBlockingQueue: [Dog, Cat, Horse] Using remove(): Dog Using poll(): Cat Updated LinkedBlockingQueue: []

---

Blockierende Operationen: put() & take()

In konkurrierenden Kontexten blockieren put() und take() den aufrufenden Thread, bis die Operation fortfahren kann, und gewährleisten so sichere Koordination zwischen Producer und Consumer.

put()

Fügt Element am Ende ein, wartet falls Queue voll.

Beispiel:

import java.util.concurrent.LinkedBlockingQueue; public class Main { public static void main(String[] args) { LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5); try { animals.put("Dog"); animals.put("Cat"); System.out.println("LinkedBlockingQueue: " + animals); } catch (InterruptedException e) { Thread.currentThread().interrupt(); System.err.println(e.getMessage()); } } }

Ausgabe

LinkedBlockingQueue: [Dog, Cat]

take()

Ruft Head-Element ab und entfernt es, blockiert falls Queue leer.

Beispiel:

import java.util.concurrent.LinkedBlockingQueue; public class Main { public static void main(String[] args) { LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5); try { animals.put("Dog"); animals.put("Cat"); System.out.println("LinkedBlockingQueue: " + animals); String removed = animals.take(); System.out.println("Removed Element: " + removed); System.out.println("New LinkedBlockingQueue: " + animals); } catch (InterruptedException e) { Thread.currentThread().interrupt(); System.err.println(e.getMessage()); } } }

Ausgabe

LinkedBlockingQueue: [Dog, Cat] Removed Element: Dog New LinkedBlockingQueue: [Cat]

---

Zusätzliche Hilfsmethoden

Methode	Beschreibung
contains(Object o)	Prüft ob Queue angegebenes Element hält.
size()	Gibt aktuelle Anzahl Elemente zurück.
toArray()	Konvertiert Queue in Array.
toString()	Liefert String-Darstellung der Queue.

---

Warum LinkedBlockingQueue wählen?

Da es intern eine verkettete Liste nutzt, bietet LinkedBlockingQueue:

• Thread-Sicherheit out of the box.
• Optionale begrenzte Kapazität für Backpressure-Kontrolle.
• Blockierende Methoden, die Producer und Consumer natürlich koordinieren.

In multithreaded Anwendungen, wo ein Thread langsamer produziert als ein anderer konsumiert, suspendiert die Queue den Consumer automatisch bis neue Items eintreffen, verhindert Busy-Waiting und reduziert CPU-Overhead.

Für hochperformante Nebenläufigkeits-Workloads empfiehlt die Java Concurrency API LinkedBlockingQueue als Go-to-Struktur für Producer-Consumer-Pipelines.

---