{"id":229,"date":"2024-02-09T23:29:05","date_gmt":"2024-02-09T22:29:05","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=229"},"modified":"2024-02-23T23:32:11","modified_gmt":"2024-02-23T22:32:11","slug":"completablefuture-in-java-ein-ueberblick","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=229","title":{"rendered":"CompletableFuture in Java – ein \u00dcberblick"},"content":{"rendered":"\n

Die CompletableFuture<\/code>-Klasse wurde mit Java 8 eingef\u00fchrt und hat die Art und Weise, wie Entwickler asynchrone Programmierung in Java angehen, grundlegend ver\u00e4ndert. Diese Klasse bietet eine m\u00e4chtige und flexible API f\u00fcr die asynchrone Programmierung und erm\u00f6glicht es Entwicklern, komplexe Aufgaben effizient zu parallelisieren. In diesem Artikel werden wir die CompletableFuture<\/code>-Klasse in Java im Detail untersuchen, ihre Funktionalit\u00e4ten, Anwendungsf\u00e4lle und bew\u00e4hrte Praktiken kennenlernen.<\/p>\n\n\n\n

1. Einf\u00fchrung in CompletableFuture<\/h2>\n\n\n\n

Die CompletableFuture<\/code>-Klasse geh\u00f6rt zum java.util.concurrent<\/code>-Paket und basiert auf dem Future-Pattern. Sie erweitert das traditionelle Future<\/code>-Konzept, indem sie Funktionalit\u00e4ten f\u00fcr asynchrone Operationen und Verkn\u00fcpfung von Futures bereitstellt. Ein CompletableFuture<\/code> repr\u00e4sentiert eine potenziell abgeschlossene Berechnung und erm\u00f6glicht es, Callbacks zu registrieren, die automatisch aufgerufen werden, wenn die Berechnung abgeschlossen ist.<\/p>\n\n\n\n

2. Grundlegende Verwendung von CompletableFuture<\/h2>\n\n\n\n

2.1. Erstellen von CompletableFuture<\/h3>\n\n\n\n

Ein CompletableFuture<\/code> kann auf verschiedene Arten erstellt werden. Eine h\u00e4ufige Methode ist CompletableFuture.supplyAsync<\/code>, die eine Berechnung asynchron ausf\u00fchrt:<\/p>\n\n\n

CompletableFuture<String<\/span>> future = CompletableFuture.supplyAsync(() -> \"Hello, CompletableFuture\"<\/span>);<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
2.2. Kombination von CompletableFuture<\/h3>\n\n\n\n
CompletableFuture<\/code> erm\u00f6glicht die Verkn\u00fcpfung von mehreren Futures, um komplexe Abl\u00e4ufe zu erstellen. Zum Beispiel k\u00f6nnen wir zwei CompletableFuture<\/code>-Objekte kombinieren und eine Aktion ausf\u00fchren, wenn beide abgeschlossen sind:<\/p>\n\n\n
CompletableFuture<String<\/span>> future1 = CompletableFuture.supplyAsync(() -> \"Hello\"<\/span>);\nCompletableFuture<String<\/span>> future2 = CompletableFuture.supplyAsync(() -> \"CompletableFuture\"<\/span>);\n\nCompletableFuture<String<\/span>> combinedFuture = future1.thenCombine(future2, (result1, result2) -> result1 + \" \"<\/span> + result2);<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
3. Verkettung von CompletableFuture<\/h2>\n\n\n\n
Eine der leistungsstarken Funktionen von CompletableFuture<\/code> ist die M\u00f6glichkeit, Aktionen zu verketten, die sequentiell oder parallel ausgef\u00fchrt werden k\u00f6nnen. Dies wird durch Methoden wie thenApply<\/code>, thenAccept<\/code>, und thenCompose<\/code> erm\u00f6glicht.<\/p>\n\n\n
CompletableFuture<String<\/span>> originalFuture = CompletableFuture.supplyAsync(() -> \"Hello\"<\/span>);\n\nCompletableFuture<String<\/span>> chainedFuture = originalFuture\n    .thenApply(result -> result + \", World\"<\/span>)\n    .thenApply(String<\/span>::toUpperCase)\n    .thenAccept(System.out::println);<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
4. Ausnahmebehandlung mit CompletableFuture<\/h2>\n\n\n\n
Die CompletableFuture<\/code>-Klasse erm\u00f6glicht auch eine effektive Behandlung von Ausnahmen. Sie k\u00f6nnen die exceptionally<\/code>-Methode verwenden, um einen Fehler abzufangen und einen Standardwert oder ein Ersatzergebnis bereitzustellen:<\/p>\n\n\n
CompletableFuture<String<\/span>> future = CompletableFuture.supplyAsync(() -> {\n    \/\/ Simulieren einer Ausnahme<\/span>\n    throw<\/span> new<\/span> RuntimeException(\"Oops! Something went wrong\"<\/span>);\n});\n\nCompletableFuture<String<\/span>> result = future.exceptionally(ex -> \"Default Value\"<\/span>);<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
5. Parallele Ausf\u00fchrung mit CompletableFuture<\/h2>\n\n\n\n
Ein entscheidender Vorteil von CompletableFuture<\/code> besteht darin, dass es einfach ist, Aufgaben parallel auszuf\u00fchren. Durch die Verwendung von Methoden wie thenCombine<\/code> und thenAcceptBoth<\/code> k\u00f6nnen Sie Ergebnisse von mehreren Futures kombinieren:<\/p>\n\n\n
CompletableFuture<String<\/span>> future1 = CompletableFuture.supplyAsync(() -> \"Hello\"<\/span>);\nCompletableFuture<String<\/span>> future2 = CompletableFuture.supplyAsync(() -> \"CompletableFuture\"<\/span>);\n\nCompletableFuture<Void> combinedFuture = future1.thenAcceptBoth(future2, (result1, result2) -> {\n    System.out.println(result1 + \" \"<\/span> + result2);\n});<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
6. Timeout und Abbruch von CompletableFuture<\/h2>\n\n\n\n
Mit CompletableFuture<\/code> k\u00f6nnen Sie auch einen Timeout f\u00fcr eine Operation festlegen und eine alternative Aktion ausf\u00fchren, wenn die Operation nicht innerhalb eines bestimmten Zeitrahmens abgeschlossen wird:<\/p>\n\n\n
CompletableFuture<String<\/span>> future = CompletableFuture.supplyAsync(() -> {\n    \/\/ Simuliere eine lang andauernde Operation<\/span>\n    try<\/span> {\n        Thread.sleep(5000<\/span>);\n    } catch<\/span> (InterruptedException e) {\n        e.printStackTrace();\n    }\n    return<\/span> \"Hello\"<\/span>;\n});\n\nCompletableFuture<String<\/span>> result = future.orTimeout(3<\/span>, TimeUnit.SECONDS)\n    .exceptionally(ex -> \"Operation timed out\"<\/span>);<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
7. CompletableFuture und CompletableFuture.allOf<\/h2>\n\n\n\n
Wenn Sie eine Gruppe von CompletableFuture<\/code>-Objekten haben und warten m\u00f6chten, bis alle abgeschlossen sind, k\u00f6nnen Sie die CompletableFuture.allOf<\/code>-Methode verwenden:<\/p>\n\n\n
CompletableFuture<String<\/span>> future1 = CompletableFuture.supplyAsync(() -> \"Hello\"<\/span>);\nCompletableFuture<String<\/span>> future2 = CompletableFuture.supplyAsync(() -> \"CompletableFuture\"<\/span>);\nCompletableFuture<String<\/span>> future3 = CompletableFuture.supplyAsync(() -> \"Java\"<\/span>);\n\nCompletableFuture<Void> allOfFuture = CompletableFuture.allOf(future1, future2, future3);\n\n\/\/ Warten, bis alle abgeschlossen sind<\/span>\nallOfFuture.join();<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
8. Fazit<\/h2>\n\n\n\n
Die CompletableFuture<\/code>-Klasse in Java bietet eine leistungsstarke M\u00f6glichkeit, asynchrone Programmierung durchzuf\u00fchren. Von der einfachen Parallelisierung von Aufgaben bis hin zur komplexen Verkettung von Aktionen und der effektiven Behandlung von Ausnahmen bietet diese Klasse eine F\u00fclle von Funktionen. Es ist wichtig, die API gr\u00fcndlich zu verstehen und bew\u00e4hrte Praktiken zu beachten, um sicherzustellen, dass Sie das volle Potenzial von CompletableFuture<\/code> nutzen und robusten, wartbaren Code schreiben.<\/p>\n","protected":false},"excerpt":{"rendered":"
Die CompletableFuture-Klasse wurde mit Java 8 eingef\u00fchrt und hat die Art und Weise, wie Entwickler asynchrone Programmierung in Java angehen, grundlegend ver\u00e4ndert. Diese Klasse bietet eine m\u00e4chtige und flexible API f\u00fcr die asynchrone Programmierung und erm\u00f6glicht es Entwicklern, komplexe Aufgaben effizient zu parallelisieren. In diesem Artikel werden wir die CompletableFuture-Klasse in Java im Detail untersuchen, […]<\/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-229","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\/229","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=229"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/229\/revisions"}],"predecessor-version":[{"id":230,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/229\/revisions\/230"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=229"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=229"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=229"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}