Lektionen

Wie man Aufgaben parallelisiert und Ergebnisse mit CompletableFuture kombiniert: zwei Ergebnisse über thenCombine/ thenCombineAsync zusammenführen, auf eine Menge von Aufgaben mit allOf warten, auf die schnellste Antwort mit anyOf reagieren. Wir besprechen Signaturen, praktische Beispiele mit supplyAsync, nicht blockierende Verarbeitung ( thenAccept, thenRun) sowie Besonderheiten von Fehlern und deren Behandlung ( exceptionally, handle, whenComplete). Am Ende – eine kompakte Vergleichstabelle der Methoden.

Wie man Ausnahmen in CompletableFuture-Ketten sicher abfängt und verarbeitet: Wir betrachten die Rollen von exceptionally (Fallback-Wert bei Fehler), handle (universeller Handler für Erfolg/Fehler) und whenComplete (Nebenaktionen ohne Änderung des Ergebnisses). Wir besprechen, warum ein direkter Aufruf von get()/ join() die Ursache in ExecutionException/ CompletionException einhüllt, wie man Schritte kombiniert ( thenApply, thenAccept) und welche typischen Fehler zu vermeiden sind.

Wie man asynchrone Schritte in CompletableFuture mit thenCompose korrekt verketten kann und wann thenApply ausreicht; wie und warum man einen eigenen Thread-Pool über ExecutorService (statt ForkJoinPool.commonPool()) einbindet; wie man Ketten vor „ewigem Warten“ mit orTimeout und completeOnTimeout schützt. Am Ende – ein Praxisbeispiel mit benutzerdefiniertem Executor, thenCompose und Timeout sowie typische Fehler und deren Lösungen.

In dieser Vorlesung betrachten wir asynchrone Ein-/Ausgabe (AIO) in Java NIO.2: worin sie sich vom synchronen IO unterscheidet, wie man mit AsynchronousFileChannel arbeitet, Lese-/Schreiboperationen über Future und CompletionHandler startet und wie die Wahl des Thread-Pools ExecutorService sich auswirkt. In der Praxis sehen wir uns das Öffnen des Channels über open, die Methoden read/ write, das Interaktionsschema und häufige Fehler an.

Wie man in Java den Abschluss asynchroner NIO2-Operationen behandelt: „Versprechen“ über Future und Rückrufe über CompletionHandler. Wir betrachten die Signaturen von read/ write bei AsynchronousFileChannel, das blockierende Abholen des Ergebnisses über get() und das Abfragen mit isDone() sowie die nicht blockierende Verarbeitung in completed()/ failed(). Wir zeigen praktische Lese-/Schreibbeispiele und einen kurzen Vergleich der Ansätze.

Wir üben asynchrone Ein-/Ausgabe in Java: Wir lesen große Textdateien blockweise in einen ByteBuffer über AsynchronousFileChannel, wandeln Bytes korrekt in Zeichen mit CharsetDecoder um und schreiben Daten asynchron zurück (über Future oder CompletionHandler). Wir beleuchten das Problem zerrissener mehrbyteiger Zeichen (zum Beispiel "UTF-8"), das Zeilenzählen während des Lesens, die Wahl der Kodierungen sowie typische Fehler beim Arbeiten mit Puffern und Kanälen.

Wie man Fehler im asynchronen Ein-/Ausgabe (I/O) von Java korrekt abfängt und behandelt: Callbacks CompletionHandler mit den Methoden completed/ failed, Logging und Benachrichtigungen. Wir betrachten den Abbruch von Operationen über Future und cancel( boolean), die Auswirkungen auf get() und CancellationException sowie praktische Tipps: try-with-resources, Synchronisierung mit CountDownLatch/ CompletableFuture und Freigabe von Ressourcen.

Praktische Analyse von Fallstricken bei der Arbeit mit asynchronem Datei-I/O in Java NIO: korrektes Puffer-Management mit ByteBuffer (Eigenschaften position/ limit, Aufrufe von flip(), clear(), compact()), Race Conditions bei parallelen Operationen mit AsynchronousFileChannel, Ressourcenfreigabe ( channel.close(), try-with-resources), Fehlerbehandlung in CompletionHandler (Methode failed(...)), Steuerung des Lebenszyklus von Operationen über Future<Integer> und Synchronisation mit CountDownLatch, korrekter Umgang mit Zeichencodierungen via CharsetDecoder sowie die Auswahl eines geeigneten Threadpools ExecutorService.

Wir analysieren, wie sich Plattform-Threads von virtuellen Threads unterscheiden: wie das Modell „ Platform Thread → OS“ funktioniert und warum es schwergewichtig ist, was sich mit virtuellen Threads ( Virtual Thread) auf Basis von carrier threads ändert und wie das Skalierbarkeit ohne reaktive “Spaghetti” ermöglicht. Wir schauen uns die Praxis mit Thread.ofVirtual() an, vergleichen das Verhalten für I/O‑bound- und CPU‑bound-Aufgaben, sprechen über Kompatibilität (blockierende Aufrufe wie InputStream.read, Socket.accept) und typische Fehler (alte Synchronisationen, die Erwartung einer „magischen Beschleunigung“).

Praxis mit virtuellen Threads in Java 21: worin sie sich von Plattform-Threads unterscheiden, wie man sie über Thread.startVirtualThread(...) und Thread.ofVirtual().start(...) startet, wann weiterhin new Thread(...) oder Thread.ofPlatform() sinnvoll ist und wie man Aufgaben massenhaft mit Executors.newVirtualThreadPerTaskExecutor() ausführt. Wir besprechen das Warten auf die Beendigung per join(), die Fehlerbehandlung mit Future und ExecutionException sowie typische Fehler beim Einsatz von Virtual Threads.

Praktischer Vergleich von plattformbasierten Threads Thread und virtuellen Threads in Java 21: wie die JVM dank der „ Carrier-Threads“ (carrier threads) Hunderttausende Aufgaben mit minimalem Speicherbedarf ausführt, wo virtuelle Threads glänzen (I/O-bound) und wo nicht (CPU-bound). Wir beleuchten Einschränkungen ( synchronized, native Sperren), Best Practices ( Executors.newVirtualThreadPerTaskExecutor()), Monitoring mit JVisualVM und Java Flight Recorder sowie typische Fehler beim Umstieg auf Virtual Threads.

Wir erläutern, wie man eine einzelne Aufgabe in einem virtuellen Thread mit Executors.newVirtualThreadPerTaskExecutor() (Java 21) startet, worin sich das von klassischen Pools ( newFixedThreadPool, newCachedThreadPool) unterscheidet, wie man korrekt über shutdown() und awaitTermination(...) beendet, Ergebnisse über Future erhält und wo virtuelle Threads den größten Vorteil bieten (massives I/O, Webserver, Belastungstests). Am Ende – typische Fehler und Feinheiten.