{"id":29078,"date":"2022-04-20T17:09:13","date_gmt":"2022-04-20T15:09:13","guid":{"rendered":"https:\/\/www.happycoders.eu\/?p=29078"},"modified":"2024-11-27T15:00:56","modified_gmt":"2024-11-27T14:00:56","slug":"delayqueue-java","status":"publish","type":"post","link":"https:\/\/www.happycoders.eu\/de\/algorithmen\/delayqueue-java\/","title":{"rendered":"DelayQueue in Java (mit Beispiel)"},"content":{"rendered":"\n

In diesem und den n\u00e4chsten Teilen dieser Tutorialserie geht es um Queues f\u00fcr spezielle Einsatzzwecke. Wir beginnen mit der DelayQueue<\/code>, einer Queue, die die Elemente nach Ablaufzeit sortiert herausgibt.<\/p>\n\n\n\n

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

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

DelayQueue Eigenschaften<\/h2>\n\n\n\n

Die Klasse java.util.concurrent.DelayQueue<\/code> ist \u2013 genau wie die PriorityQueue<\/a>, die sie intern verwendet \u2013 keine FIFO-Queue. Es wird nicht<\/em> das Element entnommen, das sich am l\u00e4ngsten in der Queue befindet. Stattdessen wird ein Element dann entnommen, wenn eine diesem Element zugeordnete Wartezeit (\"delay\") abgelaufen ist.<\/p>\n\n\n\n

Dazu m\u00fcssen die Elemente das Interface java.util.concurrent.Delayed<\/code> und dessen getDelay\u200b()<\/code>-Methode implementieren. Diese Methode liefert bei jeden Aufruf die restliche Wartezeit zur\u00fcck, die noch ablaufen muss, bis das Element aus der Queue entnommen werden darf.<\/p>\n\n\n\n

DelayQueue<\/code> ist blockierend, aber unbounded, kann also beliebig viele Elemente aufnehmen und blockiert nur bei der Entnahme (bis die Wartezeit abgelaufen ist), nicht beim Einf\u00fcgen.<\/p>\n\n\n\n

Threadsicherheit wird durch pessimistisches Locking \u00fcber ein einzelnes ReentrantLock<\/code> sichergestellt.<\/p>\n\n\n\n

Die Eigenschaften 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>
Priority Queue<\/td>Ja
(pessimistisches Locking mit einem Lock)<\/span><\/td>		Blocking
(nur dequeue)<\/span><\/td>		Nicht verf\u00fcgbar<\/td>Unbounded<\/td>Weakly consistent\u00b9<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

\u00b9 Weakly consistent: Alle Elemente, die zum Zeitpunkt der Erzeugung des Interators in der Queue liegen, werden vom Iterator genau einmal durchlaufen. \u00c4nderungen, die danach erfolgen, k\u00f6nnen \u2013 m\u00fcssen aber nicht \u2013 durch den Iterator ber\u00fccksichtigt werden.<\/p>\n\n\n\n

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

Ich habe die DelayQueue<\/code> noch nie ben\u00f6tigt und kann sie f\u00fcr keinen mir bekannten, sinnvollen Einsatzzweck empfehlen. Sie wird im JDK nur ein einziges Mal genutzt (in einer alten Swing-Klasse, die mit einem ScheduledExecutorService<\/code> wahrscheinlich eleganter h\u00e4tte implementiert werden k\u00f6nnen). Von daher ist nicht ausgeschlossen, dass sie unentdeckte Fehler enth\u00e4lt.<\/p>\n\n\n\n

DelayQueue Beispiel<\/h2>\n\n\n\n

In folgendem Beispiel (\u2192 Code auf GitHub<\/a>) wird eine DelayQueue<\/code> mit Instanzen der Klasse DelayedElement<\/code> gef\u00fcllt, welche eine Zufallszahl enthalten sowie ein zuf\u00e4lliges initiales Delay zwischen 100 und 1.000 ms. Danach wird so oft poll()<\/code> aufgerufen, bis die Queue wieder leer ist.<\/p>\n\n\n

public<\/span> class<\/span> DelayQueueExample<\/span> <\/span>{\n  public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n    BlockingQueue<DelayedElement<Integer>> queue = new<\/span> DelayQueue<>();\n    ThreadLocalRandom random = ThreadLocalRandom.current();\n    long<\/span> startTime = System.currentTimeMillis();\n\n    \/\/ Enqueue random numbers with random initial delays<\/span>\n    for<\/span> (int<\/span> i = 0<\/span>; i < 7<\/span>; i++) {\n      int<\/span> randomNumber = random.nextInt(10<\/span>, 100<\/span>);\n      int<\/span> initialDelayMillis = random.nextInt(100<\/span>, 1000<\/span>);\n      DelayedElement<Integer> element = \n          new<\/span> DelayedElement<>(randomNumber, initialDelayMillis);\n      queue.offer(element);\n      System.out.printf(\n          \"[%3dms] queue.offer(%s)   --> queue = %s%n\"<\/span>,\n          System.currentTimeMillis() - startTime, element, queue);\n    }\n\n    \/\/ Dequeue all elements<\/span>\n    while<\/span> (!queue.isEmpty()) {\n      try<\/span> {\n        DelayedElement<Integer> element = queue.take();\n        System.out.printf(\n            \"[%3dms] queue.poll() = %s --> queue = %s%n\"<\/span>,\n            System.currentTimeMillis() - startTime, element, queue);\n      } catch<\/span> (InterruptedException e) {\n        Thread.currentThread().interrupt();\n      }\n    }\n  }\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
public<\/span> class<\/span> DelayedElement<\/span><E<\/span> extends<\/span> Comparable<\/span><E<\/span>>> implements<\/span> Delayed<\/span> <\/span>{\n  private<\/span> final<\/span> E e;\n  private<\/span> final<\/span> long<\/span> initialDelayMillis;\n  private<\/span> final<\/span> long<\/span> expiration;\n\n  public<\/span> DelayedElement<\/span>(E e, long<\/span> initialDelayMillis)<\/span> <\/span>{\n    this<\/span>.e = e;\n    this<\/span>.initialDelayMillis = initialDelayMillis;\n    this<\/span>.expiration = System.currentTimeMillis() + initialDelayMillis;\n  }\n\n  @Override<\/span>\n  public<\/span> long<\/span> getDelay<\/span>(TimeUnit unit)<\/span> <\/span>{\n    long<\/span> remainingDelayMillis = expiration - System.currentTimeMillis();\n    return<\/span> unit.convert(remainingDelayMillis, TimeUnit.MILLISECONDS);\n  }\n\n  @Override<\/span>\n  public<\/span> int<\/span> compareTo<\/span>(Delayed o)<\/span> <\/span>{\n    DelayedElement<?> other = (DelayedElement<?>) o;\n    return<\/span> Long.compare(expiration, other.expiration);\n  }\n\n  @Override<\/span>\n  public<\/span> String toString<\/span>()<\/span> <\/span>{\n    return<\/span> \"{%s, %dms}\"<\/span>.formatted(e, initialDelayMillis);\n  }\n}\n<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Hier eine beispielhafte Ausgabe des Programms. Es ist gut zu sehen, wie die Queue zwar nicht sortiert ist\u00b9, das Element mit der k\u00fcrzesten Wartezeit sich jedoch immer vorne (links) befindet und dass die Elemente (ungef\u00e4hr) nach Ablauf ihrer jeweiligen Wartezeit entnommen werden:<\/p>\n\n\n
[  1ms] queue.offer({19, 713ms})   --> queue = [{19, 713ms}]\n[ 28ms] queue.offer({15, 643ms})   --> queue = [{15, 643ms}, {19, 713ms}]\n[ 29ms] queue.offer({35, 253ms})   --> queue = [{35, 253ms}, {19, 713ms}, {15, 643ms}]\n[ 29ms] queue.offer({11, 781ms})   --> queue = [{35, 253ms}, {19, 713ms}, {15, 643ms}, {11, 781ms}]\n[ 29ms] queue.offer({17, 844ms})   --> queue = [{35, 253ms}, {19, 713ms}, {15, 643ms}, {11, 781ms}, {17, 844ms}]\n[ 29ms] queue.offer({40, 490ms})   --> queue = [{35, 253ms}, {19, 713ms}, {40, 490ms}, {11, 781ms}, {17, 844ms}, {15, 643ms}]\n[ 30ms] queue.offer({39, 119ms})   --> queue = [{39, 119ms}, {19, 713ms}, {35, 253ms}, {11, 781ms}, {17, 844ms}, {15, 643ms}, {40, 490ms}]\n[151ms] queue.poll() = {39, 119ms} --> queue = [{35, 253ms}, {19, 713ms}, {40, 490ms}, {11, 781ms}, {17, 844ms}, {15, 643ms}]\n[283ms] queue.poll() = {35, 253ms} --> queue = [{40, 490ms}, {19, 713ms}, {15, 643ms}, {11, 781ms}, {17, 844ms}]\n[520ms] queue.poll() = {40, 490ms} --> queue = [{15, 643ms}, {19, 713ms}, {17, 844ms}, {11, 781ms}]\n[673ms] queue.poll() = {15, 643ms} --> queue = [{19, 713ms}, {11, 781ms}, {17, 844ms}]\n[716ms] queue.poll() = {19, 713ms} --> queue = [{11, 781ms}, {17, 844ms}]\n[811ms] queue.poll() = {11, 781ms} --> queue = [{17, 844ms}]\n[874ms] queue.poll() = {17, 844ms} --> queue = []<\/code><\/span>Code-Sprache:<\/span> Klartext<\/span> (<\/span>plaintext<\/span>)<\/span><\/small><\/pre>\n\n\n
\u00b9 Tats\u00e4chlich sieht man die Reihenfolge der Elemente in der Array-Repr\u00e4sentation des Min-Heaps.<\/p>\n\n\n\n
Zusammenfassung und Ausblick<\/h2>\n\n\n\n
In diesem Artikel hast du alles \u00fcber die DelayQueue<\/code>, ihre Eigenschaften und ihre Verwendung erfahren.<\/p>\n\n\n\n
Im n\u00e4chsten Teil dieser Serie stelle ich dir weitere Spezialqueue vor \u2013 eine die niemals Elemente enth\u00e4lt: die SynchronousQueue<\/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 DelayQueue? Wie funktioniert sie? Was sind ihre Eigenschaften? Wann sollte man sie einsetzen?<\/p>\n","protected":false},"author":1,"featured_media":29397,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_seopress_titles_title":"","_seopress_titles_desc":"Wie benutzt man die Java DelayQueue? 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":"DelayQueue","_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":6910,"_post_count":0,"footnotes":""},"categories":[127],"tags":[192],"class_list":["post-29078","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\/night-view-1277021-1770x986-1.jpg",1770,986,false],"thumbnail":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/night-view-1277021-1770x986-1.jpg",150,84,false],"medium":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/night-view-1277021-1770x986-1.jpg",300,167,false],"medium_large":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/night-view-1277021-1770x986-1.jpg",768,428,false],"large":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/night-view-1277021-1770x986-1.jpg",1024,570,false],"feature_thumb_224":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/night-view-1277021-1770x986-1-224x125.jpg",224,125,true],"feature_thumb_336":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/night-view-1277021-1770x986-1-336x187.jpg",336,187,true],"feature_thumb_504":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/night-view-1277021-1770x986-1-504x281.jpg",504,281,true],"feature_thumb_672":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/night-view-1277021-1770x986-1-672x374.jpg",672,374,true],"half_400":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/night-view-1277021-1770x986-1-400x223.jpg",400,223,true],"half_600":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/night-view-1277021-1770x986-1-600x334.jpg",600,334,true],"full_800":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/night-view-1277021-1770x986-1-800x446.jpg",800,446,true],"full_944":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/night-view-1277021-1770x986-1-944x526.jpg",944,526,true],"full_1200":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/night-view-1277021-1770x986-1-1200x668.jpg",1200,668,true],"wide_1180":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/night-view-1277021-1770x986-1-1180x490.jpg",1180,490,true],"wide_1770":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/night-view-1277021-1770x986-1-1770x735.jpg",1770,735,true],"1536x1536":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/night-view-1277021-1770x986-1.jpg",1536,856,false],"2048x2048":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/04\/night-view-1277021-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 DelayQueue? Wie funktioniert sie? Was sind ihre Eigenschaften? Wann sollte man sie einsetzen?","public_identification_id":"3e40431e6bba4ab38afc1345fd3e9629","private_identification_id":"bd09092bb79f4ec68d14a2a374b31dfb","_links":{"self":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/29078","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=29078"}],"version-history":[{"count":10,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/29078\/revisions"}],"predecessor-version":[{"id":41687,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/29078\/revisions\/41687"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/media\/29397"}],"wp:attachment":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/media?parent=29078"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/categories?post=29078"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/tags?post=29078"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
Und hier die zugeh\u00f6rige Klasse DelayedElement<\/code> (\u2192 Code auf GitHub<\/a>). Die Sortierung ist \u2013 um den Code nicht noch l\u00e4nger zu machen \u2013 nicht stabil. D. h. wenn zwei Elemente mit derselben Wartezeit in die Queue gestellt werden, werden sie in zuf\u00e4lliger Reihenfolge wieder entnommen.<\/p>\n\n\n