Diese Woche habe ich gelernt: CompletableFuture – Javas Ansatz zur asynchronen Programmierung

Diese Woche tauche ich in Javas CompletableFuture ein.

Als Full-Stack-Entwickler mit Frontend-Hintergrund ist der Umgang mit asynchronen Aufgaben ein unvermeidlicher Teil meiner Rolle – Netzwerkanfragen, Hintergrundberechnungen und dergleichen. In Java ist CompletableFuture ein leistungsstarkes Tool zur Bewältigung dieser Aufgaben, während der Hauptthread gleichzeitig reaktionsfähig bleibt.

Abschließbare Futures sind für Java das, was Promises für JavaScript sind.

Wenn Sie mit JavaScript vertraut sind, kann es hilfreich sein, diese Konzepte zu verstehen, indem Sie Parallelen zwischen beiden Sprachen herstellen. Ich stelle mir CompletableFuture gerne als Javas Version eines Versprechens vor. Es handelt sich um eine Klasse, die das letztendliche Ergebnis eines asynchronen Vorgangs darstellt, unabhängig davon, ob dieses Ergebnis ein Erfolg oder ein Misserfolg ist. Es wurde in Java 8 als Teil des Pakets java.util.concurrent eingeführt und ist eine leistungsstarke Möglichkeit, nicht blockierenden Code zu schreiben, mit Methoden zum Verketten von Vorgängen und zur Fehlerbehandlung, ähnlich wie Promises.

Hier ist ein kurzer Vergleich der beiden:

// JavaScript Promise
fetchFromServer()
    .then(data => processData(data))
    .then(result => updateUI(result))
    .catch(error => handleError(error));

// Java CompletableFuture
CompletableFuture.supplyAsync(() -> fetchDataFromServer())
    .thenApply(data -> processData(data))
    .thenAccept(result -> updateUI(result))
    .exceptionally(error -> handleError(error));

Wie oben dargestellt, bietet CompletableFuture eine ähnliche, verkettbare Syntax, die sauberen und lesbaren asynchronen Code ermöglicht.

Stellen Sie sich ein Szenario vor, in dem Sie die Profildaten und den Bestellverlauf eines Benutzers von zwei separaten Endpunkten abrufen müssen. Sie möchten vermeiden, dass die Benutzeroberfläche einfriert, während Sie auf den Abschluss dieser Anforderungen warten. So würden Sie dies mit CompletableFuture implementieren:

CompletableFuture<User> profileFuture = CompletableFuture.supplyAsync(() -> {
    // Fetch user profile from a service
});

CompletableFuture<List<Order>> ordersFuture = CompletableFuture.supplyAsync(() -> {
    // Fetch user orders from another service
});

CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(profileFuture, ordersFuture);

combinedFuture.thenRun(() -> {
    User user = userFuture.join(); 
    List<Order> orders = ordersFuture.join(); 
    displayUserData(user, orders); 
});

In diesem Beispiel lösen wir zwei asynchrone Anfragen gleichzeitig aus und verwenden allOf, um auf den Abschluss beider Anfragen zu warten. Sobald sie abgeschlossen sind, rufen wir die Ergebnisse ab und aktualisieren die Benutzeroberfläche entsprechend, ohne den Hauptthread zu blockieren.

---

Verkettungs- und Abschlussphase

CompletableFuture implementiert die CompletionStage-Schnittstelle, die die Grundlage für die Verkettung von Vorgängen bietet. Jede thenApply-, thenAccept- und ähnliche Methode gibt eine weitere CompletionStage zurück, sodass Sie komplexe asynchrone Pipelines erstellen können.

Ähnlich wie wir Versprechen in JavaScript verketten können, wenn wir eine Folge asynchroner Aufgaben haben, die nacheinander ausgeführt werden müssen, können wir Aufgaben innerhalb einer Completable Future verketten, um eine Folge abhängiger asynchroner Vorgänge zu erstellen, ohne in die Callback-Hölle zu geraten . So würden wir das machen:

CompletableFuture.supplyAsync(() -> "Hello")
    .thenApply(result -> result + ", CompletableFuture")
    .thenApply(result -> result + " in Java")
    .thenAccept(System.out::println);

Umgang mit Ausnahmen

Wo wir .catch() für ein Promise-Objekt haben, haben wir .exclusionally() für ein Completable Future. Diese Methode behandelt Ausnahmen, die während der asynchronen Verarbeitung auftreten können:

CompletableFuture.supplyAsync(() -> {
    if (true) {
        throw new RuntimeException("Exception in CompletableFuture!");
    }
    return "No exception";
}).exceptionally(ex -> {
    System.out.println("Handled exception: " + ex);
    return "Recovered value";
}).thenAccept(System.out::println);

---

Ich hoffe, dieser Artikel bietet Ihnen einen guten Ausgangspunkt, um die CompletableFuture-Klasse weiter zu erkunden.

Hilfreiche Links:

• Deep Dives zur Parallelität: Ein Leitfaden für CompletableFuture
• Eine umfassende Einführung in die asynchrone Programmierung in Java – Versprechen, Rückrufe und Zukünfte

Das obige ist der detaillierte Inhalt vonDiese Woche habe ich gelernt: CompletableFuture – Javas Ansatz zur asynchronen Programmierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!