{"id":379,"date":"2024-05-08T00:03:08","date_gmt":"2024-05-07T23:03:08","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=379"},"modified":"2024-06-05T00:05:32","modified_gmt":"2024-06-04T23:05:32","slug":"die-linkedblockingqueue-in-java","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=379","title":{"rendered":"Die LinkedBlockingQueue in Java"},"content":{"rendered":"\n

Die LinkedBlockingQueue<\/code> ist eine der Implementierungen der BlockingQueue<\/code>-Schnittstelle in Java und geh\u00f6rt zu den am h\u00e4ufigsten verwendeten Datenstrukturen in Multi-Threading-Umgebungen. Sie kombiniert die Eigenschaften einer verlinkten Liste und einer Blocking Queue und bietet eine threadsichere Warteschlange mit optionaler Kapazit\u00e4tsgrenze. Dieser Artikel beleuchtet die grundlegenden Aspekte der LinkedBlockingQueue<\/code>, ihre Verwendung und praktische Anwendungsbeispiele.<\/p>\n\n\n\n

1. Einf\u00fchrung in die LinkedBlockingQueue<\/code><\/h4>\n\n\n\n

Die LinkedBlockingQueue<\/code> befindet sich im Paket java.util.concurrent<\/code>. Eine Blocking Queue ist eine spezielle Art von Warteschlange, die blockierende Operationen zum Einf\u00fcgen (put<\/code>) und Entfernen (take<\/code>) von Elementen unterst\u00fctzt. Diese Blockierungen sind n\u00fctzlich in Multi-Threaded-Anwendungen, bei denen Threads kooperativ arbeiten m\u00fcssen, indem sie auf die Verf\u00fcgbarkeit von Ressourcen warten oder diese teilen.<\/p>\n\n\n

import<\/span> java.util.concurrent.LinkedBlockingQueue;\n\npublic class<\/span> LinkedBlockingQueueExample<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        LinkedBlockingQueue<Integer> queue = new<\/span> LinkedBlockingQueue<>(10<\/span>);\n\n        \/\/ Einf\u00fcgen eines Elements<\/span>\n        queue.offer(1<\/span>);\n\n        \/\/ Entfernen eines Elements<\/span>\n        try<\/span> {\n            Integer value = queue.take();\n            System.out.println(\"Entferntes Element: \"<\/span> + value);\n        } catch<\/span> (InterruptedException e) {\n            e.printStackTrace();\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Im obigen Beispiel erstellen wir eine LinkedBlockingQueue<\/code> mit einer Kapazit\u00e4t von 10 Elementen, f\u00fcgen ein Element hinzu und entfernen es wieder.<\/p>\n\n\n\n
2. Konstruktoren<\/h4>\n\n\n\n
Die LinkedBlockingQueue<\/code> bietet mehrere Konstruktoren:<\/p>\n\n\n\n
    \n
  • Default-Konstruktor<\/strong>: Erstellt eine unbegrenzte Warteschlange.<\/li>\n\n\n\n
  • Kapazit\u00e4tsbegrenzter Konstruktor<\/strong>: Erstellt eine Warteschlange mit einer bestimmten maximalen Kapazit\u00e4t.<\/li>\n\n\n\n
  • Kopierender Konstruktor<\/strong>: Erstellt eine Warteschlange, die die Elemente einer gegebenen Collection kopiert.<\/li>\n<\/ul>\n\n\n
    \/\/ Unbegrenzte Warteschlange\nLinkedBlockingQueue<Integer<\/span>><\/span> unboundedQueue = new LinkedBlockingQueue<><\/span>();\n\n\/\/ Warteschlange mit Kapazit\u00e4t 100\nLinkedBlockingQueue<Integer<\/span>><\/span> boundedQueue = new LinkedBlockingQueue<><\/span>(100);\n\n\/\/ Warteschlange aus einer bestehenden Sammlung\nCollection<Integer<\/span>><\/span> collection = Arrays.asList(1, 2, 3, 4, 5);\nLinkedBlockingQueue<Integer<\/span>><\/span> queueFromCollection = new LinkedBlockingQueue<><\/span>(collection);<\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
    3. Methoden<\/h4>\n\n\n\n
    Die LinkedBlockingQueue<\/code> bietet eine Vielzahl von Methoden zur Manipulation der Warteschlange:<\/p>\n\n\n\n
      \n
    • Einf\u00fcgen von Elementen<\/strong>:<\/li>\n\n\n\n
    • add(E e)<\/code>: F\u00fcgt ein Element hinzu, wenn m\u00f6glich, und wirft eine IllegalStateException<\/code>, wenn die Warteschlange voll ist.<\/li>\n\n\n\n
    • offer(E e)<\/code>: F\u00fcgt ein Element hinzu, wenn m\u00f6glich, und gibt false<\/code> zur\u00fcck, wenn die Warteschlange voll ist.<\/li>\n\n\n\n
    • put(E e)<\/code>: F\u00fcgt ein Element hinzu und blockiert, wenn die Warteschlange voll ist.<\/li>\n\n\n\n
    • Entfernen von Elementen<\/strong>:<\/li>\n\n\n\n
    • poll()<\/code>: Entfernt und liefert das Kopf-Element, oder null<\/code>, wenn die Warteschlange leer ist.<\/li>\n\n\n\n
    • take()<\/code>: Entfernt und liefert das Kopf-Element und blockiert, wenn die Warteschlange leer ist.<\/li>\n\n\n\n
    • remove(Object o)<\/code>: Entfernt ein bestimmtes Element aus der Warteschlange.<\/li>\n\n\n\n
    • Pr\u00fcfen der Warteschlange<\/strong>:<\/li>\n\n\n\n
    • peek()<\/code>: Liefert das Kopf-Element, ohne es zu entfernen, oder null<\/code>, wenn die Warteschlange leer ist.<\/li>\n\n\n\n
    • isEmpty()<\/code>: Pr\u00fcft, ob die Warteschlange leer ist.<\/li>\n\n\n\n
    • size()<\/code>: Liefert die Anzahl der Elemente in der Warteschlange.<\/li>\n<\/ul>\n\n\n\n
      Hier sind einige Beispiele zur Demonstration der wichtigsten Methoden:<\/p>\n\n\n
      LinkedBlockingQueue<Integer> queue = new<\/span> LinkedBlockingQueue<>(5<\/span>);\n\n\/\/ Hinzuf\u00fcgen von Elementen<\/span>\nqueue.add(1<\/span>);\nqueue.offer(2<\/span>);\n\ntry<\/span> {\n    queue.put(3<\/span>);\n} catch<\/span> (InterruptedException e) {\n    e.printStackTrace();\n}\n\n\/\/ \u00dcberpr\u00fcfen der Gr\u00f6\u00dfe<\/span>\nSystem.out.println(\"Gr\u00f6\u00dfe der Warteschlange: \"<\/span> + queue.size()); \/\/ Ausgabe: 3<\/span>\n\n\/\/ Zugriff auf das Kopf-Element<\/span>\nSystem.out.println(\"Kopf-Element: \"<\/span> + queue.peek()); \/\/ Ausgabe: 1<\/span>\n\n\/\/ Entfernen von Elementen<\/span>\nSystem.out.println(\"Entferntes Element: \"<\/span> + queue.poll()); \/\/ Ausgabe: 1<\/span><\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      4. Blockierende Operationen<\/h4>\n\n\n\n
      Die blockierenden Operationen der LinkedBlockingQueue<\/code> sind besonders n\u00fctzlich in Producer-Consumer-Szenarien. Hier ein Beispiel, das zeigt, wie Producer- und Consumer-Threads mit einer LinkedBlockingQueue<\/code> interagieren k\u00f6nnen:<\/p>\n\n\n
      import java.util.concurrent.LinkedBlockingQueue;\n\nclass<\/span> Producer<\/span> implements<\/span> Runnable<\/span> <\/span>{\n    private<\/span> final<\/span> LinkedBlockingQueue<Integer> queue;\n\n    public<\/span> Producer(LinkedBlockingQueue<Integer> queue) {\n        this.queue = queue;\n    }\n\n    @Override\n    public<\/span> void run() {\n        try<\/span> {\n            for<\/span> (int i = 0<\/span>; i < 10<\/span>; i++) {\n                System.out.println(\"Producing: \"<\/span> + i);\n                queue.put(i);\n                Thread.sleep(100<\/span>); \/\/ Simuliert Produktionszeit<\/span>\n            }\n        } catch<\/span> (InterruptedException e) {\n            Thread.currentThread().interrupt();\n        }\n    }\n}\n\nclass<\/span> Consumer<\/span> implements<\/span> Runnable<\/span> <\/span>{\n    private<\/span> final<\/span> LinkedBlockingQueue<Integer> queue;\n\n    public<\/span> Consumer(LinkedBlockingQueue<Integer> queue) {\n        this.queue = queue;\n    }\n\n    @Override\n    public<\/span> void run() {\n        try<\/span> {\n            while<\/span> (true<\/span>) {\n                Integer value = queue.take();\n                System.out.println(\"Consuming: \"<\/span> + value);\n                Thread.sleep(150<\/span>); \/\/ Simuliert Konsumzeit<\/span>\n            }\n        } catch<\/span> (InterruptedException e) {\n            Thread.currentThread().interrupt();\n        }\n    }\n}\n\npublic<\/span> class<\/span> ProducerConsumerExample<\/span> <\/span>{\n    public<\/span> static<\/span> void main(String[] args) {\n        LinkedBlockingQueue<Integer> queue = new<\/span> LinkedBlockingQueue<>(5<\/span>);\n\n        Producer producer = new<\/span> Producer(queue);\n        Consumer consumer = new<\/span> Consumer(queue);\n\n        Thread producerThread = new<\/span> Thread(producer);\n        Thread consumerThread = new<\/span> Thread(consumer);\n\n        producerThread.start();\n        consumerThread.start();\n    }\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
      In diesem Beispiel produziert der Producer<\/code>-Thread kontinuierlich Elemente und f\u00fcgt sie der Warteschlange hinzu, w\u00e4hrend der Consumer<\/code>-Thread diese Elemente aus der Warteschlange entfernt und konsumiert. Die blockierenden Methoden put<\/code> und take<\/code> sorgen daf\u00fcr, dass die Threads warten, wenn die Warteschlange voll oder leer ist, wodurch eine sichere und effiziente Koordination zwischen den Threads erm\u00f6glicht wird.<\/p>\n\n\n\n
      5. Kapazit\u00e4tsmanagement und Thread-Sicherheit<\/h4>\n\n\n\n
      Die LinkedBlockingQueue<\/code> kann mit oder ohne Kapazit\u00e4tsbegrenzung verwendet werden. Wenn keine Kapazit\u00e4tsbegrenzung angegeben wird, verh\u00e4lt sich die Warteschlange wie eine unbeschr\u00e4nkte Warteschlange, was in Umgebungen mit unvorhersehbarem Lastaufkommen zu Problemen f\u00fchren kann. Die Begrenzung der Kapazit\u00e4t kann dazu beitragen, die Ressourcen zu verwalten und sicherzustellen, dass die Anwendung stabil bleibt.<\/p>\n\n\n
      LinkedBlockingQueue<Integer<\/span>><\/span> limitedQueue = new LinkedBlockingQueue<><\/span>(100);<\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
      Ein weiterer wichtiger Aspekt ist die Thread-Sicherheit. Die LinkedBlockingQueue<\/code> verwendet interne Sperren (Locks) und Bedingungen (Conditions), um sicherzustellen, dass alle Operationen atomar und threadsicher sind. Dies bedeutet, dass mehrere Threads sicher auf dieselbe Warteschlange zugreifen k\u00f6nnen, ohne dass zus\u00e4tzliche Synchronisationsmechanismen erforderlich sind.<\/p>\n\n\n\n
      6. Anwendungsbeispiele<\/h4>\n\n\n\n
      Die LinkedBlockingQueue<\/code> findet in vielen realen Anwendungen Einsatz, insbesondere dort, wo eine sichere und effiziente Kommunikation zwischen Threads erforderlich ist. Beispiele umfassen:<\/p>\n\n\n\n
        \n
      • Log-Verarbeitungssysteme<\/strong>: Ein Producer-Thread schreibt Log-Meldungen in eine Warteschlange, w\u00e4hrend ein Consumer-Thread die Nachrichten aus der Warteschlange liest und verarbeitet.<\/li>\n\n\n\n
      • Auftragsverarbeitung<\/strong>: In einem Webserver k\u00f6nnen Anfragen in eine Warteschlange gestellt werden, die von Worker-Threads verarbeitet wird.<\/li>\n\n\n\n
      • Daten-Pipelines<\/strong>: In Datenverarbeitungssystemen k\u00f6nnen Daten von einem Schritt zum n\u00e4chsten durch eine Reihe von Warteschlangen weitergeleitet werden, wobei jeder Schritt von einem eigenen Thread oder Thread-Pool durchgef\u00fchrt wird.<\/li>\n<\/ul>\n\n\n\n
        7. Fazit<\/h4>\n\n\n\n
        Die LinkedBlockingQueue<\/code> ist eine vielseitige und leistungsf\u00e4hige Datenstruktur in Java, die sich ideal f\u00fcr Multi-Threading-Szenarien eignet. Durch ihre blockierenden Operationen und die F\u00e4higkeit, eine Kapazit\u00e4tsgrenze zu setzen, bietet sie eine robuste L\u00f6sung f\u00fcr die Synchronisation und Kommunikation zwischen Threads. Ob in einfachen Producer-Consumer-Modellen oder komplexen Datenverarbeitungssystemen, die LinkedBlockingQueue<\/code> ist ein unverzichtbares Werkzeug in der Toolbox eines Java-Entwicklers.<\/p>\n\n\n\n
        Mit der richtigen Anwendung und einem guten Verst\u00e4ndnis der zugrunde liegenden Mechanismen kann die LinkedBlockingQueue<\/code> dazu beitragen, Multi-Threaded-Anwendungen effizienter und stabiler zu gestalten.<\/p>\n","protected":false},"excerpt":{"rendered":"
        Die LinkedBlockingQueue ist eine der Implementierungen der BlockingQueue-Schnittstelle in Java und geh\u00f6rt zu den am h\u00e4ufigsten verwendeten Datenstrukturen in Multi-Threading-Umgebungen. Sie kombiniert die Eigenschaften einer verlinkten Liste und einer Blocking Queue und bietet eine threadsichere Warteschlange mit optionaler Kapazit\u00e4tsgrenze. Dieser Artikel beleuchtet die grundlegenden Aspekte der LinkedBlockingQueue, ihre Verwendung und praktische Anwendungsbeispiele. 1. Einf\u00fchrung in […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-379","post","type-post","status-publish","format-standard","hentry","category-plain_java"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/379","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=379"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/379\/revisions"}],"predecessor-version":[{"id":380,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/379\/revisions\/380"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=379"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=379"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=379"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}