Umgang mit Multithreading in Java mit Completable Future

1. Completable Future verstehen

CompletableFuture ist Teil des java.util.concurrent-Pakets und bietet eine Möglichkeit, asynchronen, nicht blockierenden Code besser lesbar und wartbar zu schreiben. Es stellt ein zukünftiges Ergebnis einer asynchronen Berechnung dar.

1.1 Erstellen einer einfachen CompletableFuture

Um mit CompletableFuture zu beginnen, können Sie eine einfache asynchrone Aufgabe erstellen. Hier ist ein Beispiel:

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("Running asynchronously...");
            // Simulate a long-running task
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        future.join(); // Wait for the task to complete
        System.out.println("Task completed.");
    }
}

• CompletableFuture.runAsync() führt eine Aufgabe asynchron aus.
• future.join() blockiert den Hauptthread, bis die Aufgabe abgeschlossen ist.

Demo-Ergebnis:

Running asynchronously...
Task completed.

1.2 CompletableFuture mit Ergebnissen verwenden

Sie können CompletableFuture auch verwenden, um Ergebnisse von asynchronen Aufgaben zurückzugeben:

import java.util.concurrent.CompletableFuture;

public class CompletableFutureWithResult {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            // Simulate a computation
            return 5 * 5;
        });

        future.thenAccept(result -> {
            System.out.println("The result is: " + result);
        }).join();
    }
}

• CompletableFuture.supplyAsync() wird für Aufgaben verwendet, die ein Ergebnis zurückgeben.
• thenAccept() verarbeitet das Ergebnis, sobald die Berechnung abgeschlossen ist.

Demo-Ergebnis:

The result is: 25

2. Kombinieren mehrerer CompletableFutures

Die Bearbeitung mehrerer asynchroner Aufgaben ist ein häufiger Anwendungsfall. CompletableFuture bietet mehrere Methoden zum Kombinieren von Futures.

2.1 Kombinieren von Futures mit thenCombine

Sie können Ergebnisse aus mehreren CompletableFutures kombinieren:

import java.util.concurrent.CompletableFuture;

public class CombiningFutures {
    public static void main(String[] args) {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 5);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 10);

        CompletableFuture<Integer> combinedFuture = future1.thenCombine(future2, (result1, result2) -> result1 + result2);

        combinedFuture.thenAccept(result -> {
            System.out.println("Combined result: " + result);
        }).join();
    }
}

• thenCombine () kombiniert die Ergebnisse zweier Futures.
• Das kombinierte Ergebnis wird mit thenAccept () verarbeitet.

Demo-Ergebnis:

Combined result: 15

2.2 Umgang mit mehreren Futures mit allOf

Wenn Sie auf den Abschluss mehrerer Futures warten müssen, verwenden Sie CompletableFuture.allOf():

import java.util.concurrent.CompletableFuture;

public class AllOfExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
            // Simulate task
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
            // Simulate another task
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        CompletableFuture<Void> allOfFuture = CompletableFuture.allOf(future1, future2);

        allOfFuture.join();
        System.out.println("All tasks completed.");
    }
}

• CompletableFuture.allOf() wartet auf den Abschluss aller gegebenen Futures.
• join() stellt sicher, dass der Hauptthread wartet, bis alle Aufgaben erledigt sind.

Demo-Ergebnis:

All tasks completed.

3. Fehlerbehandlung mit CompletableFuture

Der Umgang mit Fehlern ist bei der asynchronen Programmierung unerlässlich. CompletableFuture bietet Methoden zum Verwalten von Ausnahmen.

3.1 Ausnahmen mit außergewöhnlich behandeln

Verwenden Sie Exceptionally (), um Ausnahmen in asynchronen Aufgaben zu behandeln:

import java.util.concurrent.CompletableFuture;

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            throw new RuntimeException("Something went wrong!");
        }).exceptionally(ex -> {
            System.out.println("Exception occurred: " + ex.getMessage());
            return null;
        });

        future.join();
    }
}

• Exceptionally () fängt Ausnahmen ab und behandelt sie.
• Es ermöglicht Ihnen, ein Fallback-Ergebnis bereitzustellen oder den Fehler zu behandeln.

Demo-Ergebnis:

Exception occurred: Something went wrong!

4. Vor- und Nachteile von CompletableFuture

4.1 Vorteile

• Asynchrone Ausführung: Behandelt Aufgaben, die gleichzeitig ausgeführt werden, effizient, ohne den Hauptthread zu blockieren.
• Verbesserte Lesbarkeit: Bietet eine besser lesbare und wartbare Möglichkeit, asynchronen Code im Vergleich zu herkömmlichen Callback-Ansätzen zu verarbeiten.
• Rich API: Bietet eine Vielzahl von Methoden zum Kombinieren, Bearbeiten und Zusammenstellen mehrerer Futures.

4.2 Nachteile

• Komplexität: Obwohl CompletableFuture leistungsstark ist, kann es zu Komplexität bei der Verwaltung und beim Debuggen von asynchronem Code führen.
• Ausnahmebehandlung: Die Behandlung von Ausnahmen kann manchmal schwierig sein, insbesondere in komplexen Szenarien mit mehreren Phasen.

5. Fazit

In diesem Leitfaden haben wir untersucht, wie CompletableFuture zur Verarbeitung gleichzeitiger Anforderungen in Java verwendet werden kann. Von der Erstellung einfacher asynchroner Aufgaben bis hin zur Kombination mehrerer Futures und der Fehlerbehandlung bietet CompletableFuture einen robusten und flexiblen Ansatz für die asynchrone Programmierung.

Wenn Sie Fragen haben oder weitere Hilfe benötigen, können Sie unten gerne einen Kommentar hinterlassen. Ich helfe gerne!

Weitere Beiträge finden Sie unter: Umgang mit Multithreading in Java mit Completable Future

Das obige ist der detaillierte Inhalt vonUmgang mit Multithreading in Java mit Completable Future. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!