{"id":29082,"date":"2022-04-20T17:10:24","date_gmt":"2022-04-20T15:10:24","guid":{"rendered":"https:\/\/www.happycoders.eu\/?p=29082"},"modified":"2024-11-27T15:10:30","modified_gmt":"2024-11-27T14:10:30","slug":"synchronousqueue-java","status":"publish","type":"post","link":"https:\/\/www.happycoders.eu\/de\/algorithmen\/synchronousqueue-java\/","title":{"rendered":"SynchronousQueue in Java (mit Beispiel)"},"content":{"rendered":"\n

In diesem Artikel geht es um eine sehr spezielle Queue \u2013 die SynchronousQueue<\/code>, deren Eigenschaften und Einsatzgebiete. Anhand eines Beispiels siehst du, wie man die SynchronousQueue<\/code> einsetzt.<\/p>\n\n\n\n

Hier befinden wir uns in der Klassenhierarchie:<\/p>\n\n\n\n

\"SynchronousQueue
SynchronousQueue in der Klassenhierarchie<\/figcaption><\/figure><\/div>\n\n\n\n

SynchronousQueue Eigenschaften<\/h2>\n\n\n\n

Das \u201cSynchronous\u201d in der Klasse java.util.concurrent.SynchronousQueue<\/code> ist nicht mit \"synchronized\" zu verwechseln. Es bedeutet vielmehr, dass jede Enqueue-Operation auf eine korrespondierende Dequeue-Operation warten muss und jede Dequeue-Operation auf eine Enqueue-Operation.<\/p>\n\n\n\n

Eine SynchronousQueue<\/code> enth\u00e4lt niemals Elemente, auch dann nicht, wenn Enqueue-Operationen gerade auf Dequeue-Operationen warten. Analog dazu ist die Gr\u00f6\u00dfe einer SynchronousQueue<\/code> immer 0, und peek()<\/code> liefert immer null<\/code> zur\u00fcck.<\/p>\n\n\n\n

Die SynchronousQueue<\/code> und die ArrayBlockingQueue<\/a> sind die einzigen Queue-Implementierungen, die eine Fairness Policy anbieten. Hierbei gibt es eine Besonderheit: Wenn die Fairness Policy nicht aktiviert ist, werden blockierende Aufrufe laut Dokumentation in unspezifizierter Reihenfolge bedient. Tats\u00e4chlich ist es jedoch so, dass diese exakt in umgekehrter Reihenfolge bedient werden (also in LIFO-Reihenfolge), da intern ein Stack verwendet wird.<\/p>\n\n\n\n

Die Eigenschaften der SynchronousQueue<\/code> im Detail:<\/p>\n\n\n\n

Unterliegende Datenstruktur<\/th>Thread-safe?<\/th>Blocking\/
Non-blocking<\/th>		Fairness
Policy<\/th>		Bounded\/
Unbounded<\/th>		Iterator Type<\/th><\/tr><\/thead>
Stack
(implementiert mit verketteter Liste)<\/span><\/td>		Ja
(optimistisches Locking durch Compare-and-set)<\/span><\/td>		Blocking<\/td>Optional<\/td>Unbounded<\/td>Der Iterator ist immer leer.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

Einsatzempfehlung<\/h3>\n\n\n\n

Genau wie die DelayQueue<\/a> und die LinkedTransferQueue<\/a> habe ich auch die SynchronousQueue<\/code> in eigenen Projekten noch nie direkt eingesetzt.<\/p>\n\n\n\n

Sollten ihre Eigenschaften zu deinen Anforderungen passen, kannst du sie bedenkenlos verwenden. Im JDK wird die SynchronousQueue<\/code> von Executors.newCachedThreadPool()<\/code> als \u201ework queue\u201c f\u00fcr den Executor eingesetzt; die Wahrscheinlichkeit von Bugs ist also \u00e4u\u00dferst gering.<\/p>\n\n\n\n

SynchronousQueue Beispiel<\/h2>\n\n\n\n

Im folgende Beispiel (\u2192 Code auf GitHub<\/a>) werden zun\u00e4chst drei Threads gestartet, die SynchronousQueue.put()<\/code> aufrufen, danach sechs Threads, die SynchronousQueue.take()<\/code> aufrufen und anschlie\u00dfend noch einmal drei Threads, die SynchronousQueue.put()<\/code> ausf\u00fchren:<\/p>\n\n\n

public<\/span> class<\/span> SynchronousQueueExample<\/span> <\/span>{\n  private<\/span> static<\/span> final<\/span> boolean<\/span> FAIR = false<\/span>;\n\n  public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> throws<\/span> InterruptedException <\/span>{\n    BlockingQueue<Integer> queue = new<\/span> SynchronousQueue<>(FAIR);\n\n    \/\/ Start 3 producing threads<\/span>\n    for<\/span> (int<\/span> i = 0<\/span>; i < 3<\/span>; i++) {\n      int<\/span> element = i; \/\/ Assign to an effectively final variable<\/span>\n      new<\/span> Thread(() -> enqueue(queue, element)).start();\n      Thread.sleep(250<\/span>);\n    }\n\n    \/\/ Start 6 consuming threads<\/span>\n    for<\/span> (int<\/span> i = 0<\/span>; i < 6<\/span>; i++) {\n      new<\/span> Thread(() -> dequeue(queue)).start();\n      Thread.sleep(250<\/span>);\n    }\n\n    \/\/ Start 3 more producing threads<\/span>\n    for<\/span> (int<\/span> i = 3<\/span>; i < 6<\/span>; i++) {\n      int<\/span> element = i; \/\/ Assign to an effectively final variable<\/span>\n      new<\/span> Thread(() -> enqueue(queue, element)).start();\n      Thread.sleep(250<\/span>);\n    }\n  }\n\n  private<\/span> static<\/span> void<\/span> enqueue<\/span>(BlockingQueue<Integer> queue, int<\/span> element)<\/span> <\/span>{\n    log(\"Calling queue.put(%d) (queue = %s)...\"<\/span>, element, queue);\n    try<\/span> {\n      queue.put(element);\n      log(\"queue.put(%d) returned (queue = %s)\"<\/span>, element, queue);\n    } catch<\/span> (InterruptedException e) {\n      Thread.currentThread().interrupt();\n    }\n  }\n\n  private<\/span> static<\/span> void<\/span> dequeue<\/span>(BlockingQueue<Integer> queue)<\/span> <\/span>{\n    log(\"    Calling queue.take() (queue = %s)...\"<\/span>, queue);\n    try<\/span> {\n      Integer element = queue.take();\n      log(\"    queue.take() returned %d (queue = %s)\"<\/span>, element, queue);\n    } catch<\/span> (InterruptedException e) {\n      Thread.currentThread().interrupt();\n    }\n  }\n\n  private<\/span> static<\/span> void<\/span> log<\/span>(String format, Object... args)<\/span> <\/span>{\n    System.out.printf(\n        Locale.US,\n        \"[%-9s] %s%n\"<\/span>,\n        Thread.currentThread().getName(),\n        String.format(format, args));\n  }\n}\n<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
In der Ausgabe kannst du sehen, wie die ersten drei Aufrufe von put()<\/code> durch die Threads 0, 1 und 2 solange blockieren, bis die eingef\u00fcgten Elemente mit take()<\/code> durch die Threads 3, 4 und 5 in umgekehrter Reihenfolge entnommen werden.<\/p>\n\n\n\n
Danach blockieren die drei folgenden Aufrufe von take()<\/code> (Threads 6, 7, 8) solange bis mit put()<\/code> drei weitere Elemente in die Queue geschrieben wurden (Threads 9, 10, 11).<\/p>\n\n\n\n
Die Queue bleibt w\u00e4hrend der gesamten Zeit leer.<\/p>\n\n\n
[Thread-0 ] Calling queue.put(0) (queue = [])...\n[Thread-1 ] Calling queue.put(1) (queue = [])...\n[Thread-2 ] Calling queue.put(2) (queue = [])...\n[Thread-3 ]     Calling queue.take() (queue = [])...\n[Thread-3 ]     queue.take() returned 2 (queue = [])\n[Thread-2 ] queue.put(2) returned (queue = [])\n[Thread-4 ]     Calling queue.take() (queue = [])...\n[Thread-4 ]     queue.take() returned 1 (queue = [])\n[Thread-1 ] queue.put(1) returned (queue = [])\n[Thread-5 ]     Calling queue.take() (queue = [])...\n[Thread-5 ]     queue.take() returned 0 (queue = [])\n[Thread-0 ] queue.put(0) returned (queue = [])\n[Thread-6 ]     Calling queue.take() (queue = [])...\n[Thread-7 ]     Calling queue.take() (queue = [])...\n[Thread-8 ]     Calling queue.take() (queue = [])...\n[Thread-9 ] Calling queue.put(3) (queue = [])...\n[Thread-9 ] queue.put(3) returned (queue = [])\n[Thread-8 ]     queue.take() returned 3 (queue = [])\n[Thread-10] Calling queue.put(4) (queue = [])...\n[Thread-10] queue.put(4) returned (queue = [])\n[Thread-7 ]     queue.take() returned 4 (queue = [])\n[Thread-11] Calling queue.put(5) (queue = [])...\n[Thread-11] queue.put(5) returned (queue = [])\n[Thread-6 ]     queue.take() returned 5 (queue = [])<\/code><\/span>Code-Sprache:<\/span> Klartext<\/span> (<\/span>plaintext<\/span>)<\/span><\/small><\/pre>\n\n\n
Wenn du die Konstante FAIR<\/code> auf true<\/code> setzt, wirst du sehen, wie die Elemente nicht in LIFO-, sondern in FIFO-Reihenfolge entnommen werden.<\/p>\n\n\n\n
Zusammenfassung und Ausblick<\/h2>\n\n\n\n
In diesem Artikel hast du die SynchronousQueue<\/code> kennengelernt \u2013 eine Queue, die niemals Elemente enth\u00e4lt, sondern diese direkt von den enqueuenden Threads an die dequeuenden Threads \u00fcbergibt.<\/p>\n\n\n\n
Im n\u00e4chsten Teil geht es um die letzte Queue-Impementierung dieser Tutorial-Serie: die LinkedTransferQueue<\/a>.<\/p>\n\n\n\n
Wenn du noch Fragen hast, stelle sie gerne \u00fcber die Kommentar-Funktion. M\u00f6chtest du \u00fcber neue Tutorials und Artikel informiert werden? Dann klicke hier<\/a>, um dich f\u00fcr den HappyCoders.eu-Newsletter anzumelden.<\/p>\n","protected":false},"excerpt":{"rendered":"
Wie benutzt man die Java SynchronousQueue? Wie funktioniert sie? Was sind ihre Eigenschaften? Wann sollte man sie einsetzen?<\/p>\n","protected":false},"author":1,"featured_media":29395,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_seopress_titles_title":"","_seopress_titles_desc":"Wie benutzt man die Java SynchronousQueue? Wie funktioniert sie? Was sind ihre Eigenschaften? Wann sollte man sie einsetzen?","_seopress_robots_index":"","_seopress_robots_follow":"","_seopress_robots_imageindex":"","_seopress_robots_snippet":"","_seopress_robots_primary_cat":"none","_seopress_robots_breadcrumbs":"","_seopress_robots_freeze_modified_date":"","_seopress_robots_custom_modified_date":"","_seopress_robots_canonical":"","_seopress_social_fb_title":"","_seopress_social_fb_desc":"","_seopress_social_fb_img":"","_seopress_social_fb_img_attachment_id":0,"_seopress_social_fb_img_width":0,"_seopress_social_fb_img_height":0,"_seopress_social_twitter_title":"","_seopress_social_twitter_desc":"","_seopress_social_twitter_img":"","_seopress_social_twitter_img_attachment_id":0,"_seopress_social_twitter_img_width":0,"_seopress_social_twitter_img_height":0,"_seopress_redirections_value":"","_seopress_redirections_enabled":"","_seopress_redirections_enabled_regex":"","_seopress_redirections_logged_status":"both","_seopress_redirections_param":"","_seopress_redirections_type":301,"_seopress_analysis_target_kw":"SynchronousQueue","_seopress_news_disabled":"","_seopress_video_disabled":"","_seopress_video":[],"_seopress_pro_schemas_manual":[{"_seopress_pro_rich_snippets_type":"none"}],"_seopress_pro_rich_snippets_disable_all":"","_seopress_pro_rich_snippets_disable":[],"_seopress_pro_schemas":[],"_uag_custom_page_level_css":"","_wp_convertkit_post_meta":{"form":"-1","landing_page":"","tag":"0","restrict_content":"0"},"_metis_text_type":"standard","_metis_text_length":6435,"_post_count":0,"footnotes":""},"categories":[127],"tags":[192],"class_list":["post-29082","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-algorithmen","tag-datenstrukturen-queue"],"uagb_featured_image_src":{"full":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/dragon-3399792-1770x986-1.jpg",1770,986,false],"thumbnail":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/dragon-3399792-1770x986-1.jpg",150,84,false],"medium":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/dragon-3399792-1770x986-1.jpg",300,167,false],"medium_large":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/dragon-3399792-1770x986-1.jpg",768,428,false],"large":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/dragon-3399792-1770x986-1.jpg",1024,570,false],"feature_thumb_224":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/dragon-3399792-1770x986-1-224x125.jpg",224,125,true],"feature_thumb_336":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/dragon-3399792-1770x986-1-336x187.jpg",336,187,true],"feature_thumb_504":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/dragon-3399792-1770x986-1-504x281.jpg",504,281,true],"feature_thumb_672":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/dragon-3399792-1770x986-1-672x374.jpg",672,374,true],"half_400":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/dragon-3399792-1770x986-1-400x223.jpg",400,223,true],"half_600":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/dragon-3399792-1770x986-1-600x334.jpg",600,334,true],"full_800":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/dragon-3399792-1770x986-1-800x446.jpg",800,446,true],"full_944":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/dragon-3399792-1770x986-1-944x526.jpg",944,526,true],"full_1200":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/dragon-3399792-1770x986-1-1200x668.jpg",1200,668,true],"wide_1180":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/dragon-3399792-1770x986-1-1180x490.jpg",1180,490,true],"wide_1770":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/dragon-3399792-1770x986-1-1770x735.jpg",1770,735,true],"1536x1536":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/dragon-3399792-1770x986-1.jpg",1536,856,false],"2048x2048":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/dragon-3399792-1770x986-1.jpg",1770,986,false]},"uagb_author_info":{"display_name":"Sven Woltmann","author_link":"https:\/\/www.happycoders.eu\/de\/author\/sven\/"},"uagb_comment_info":0,"uagb_excerpt":"Wie benutzt man die Java SynchronousQueue? Wie funktioniert sie? Was sind ihre Eigenschaften? Wann sollte man sie einsetzen?","public_identification_id":"3d9b9b38f0a9422f919123878d069d2c","private_identification_id":"b8874e00b857499b92f9cabf3ff5bd01","_links":{"self":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/29082","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/comments?post=29082"}],"version-history":[{"count":10,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/29082\/revisions"}],"predecessor-version":[{"id":41712,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/29082\/revisions\/41712"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/media\/29395"}],"wp:attachment":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/media?parent=29082"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/categories?post=29082"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/tags?post=29082"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}