So verwenden Sie CompletableFuture in Java, um zu benachrichtigen, wenn alle Elemente verarbeitet werden

CompletableFuture in Java ist ein sehr leistungsfähiges asynchrones Programmiertool. Es kann uns dabei helfen, Aufgabenzustellung, Verarbeitung, Benachrichtigung und andere Vorgänge während der asynchronen Verarbeitung durchzuführen, wodurch die Schwierigkeit der asynchronen Programmierung erheblich vereinfacht wird. Bei der Verwendung von CompletableFuture für die asynchrone Verarbeitung gibt es ein Szenario, in dem eine Benachrichtigung erforderlich ist, nachdem alle Elemente verarbeitet wurden. In diesem Artikel wird erläutert, wie Sie CompletableFuture in Java zum Implementieren dieses Szenarios verwenden.

Zunächst müssen Sie die grundlegenden Konzepte und die Verwendung von CompletableFuture verstehen. CompletableFuture ist eine neue Klasse in Java 8, die eine Möglichkeit bietet, Ergebnisse bei der asynchronen Ausführung von Vorgängen zu verarbeiten. Dadurch können wir mehrere asynchrone Vorgänge zu einem komplexeren Vorgang kombinieren und warten, bis alle asynchronen Vorgänge abgeschlossen sind, bevor wir mit dem nächsten Schritt fortfahren.

Im Szenario der Benachrichtigung, wenn alle Elemente verarbeitet sind, müssen wir die Methode von CompletableFuture: allOf verwenden. Diese Methode kann mehrere CompletableFuture-Objekte miteinander kombinieren und ein neues CompletableFuture-Objekt zurückgeben, nachdem darauf gewartet wurde, dass die asynchronen Aufgaben aller Objekte abgeschlossen sind.

Die grundlegenden Schritte bei der Verwendung der allOf-Methode sind wie folgt:

1. Erstellen Sie mehrere CompletableFuture-Objekte, um verschiedene Elemente zu verarbeiten.
2. Rufen Sie die CompletableFuture.allOf-Methode auf, übergeben Sie alle CompletableFuture-Objekte als Parameter und warten Sie, bis alle asynchronen Aufgaben abgeschlossen sind.
3. Nachdem alle asynchronen Aufgaben abgeschlossen sind, gibt die allOf-Methode ein neues CompletableFuture-Objekt zurück, das für die nächste Verarbeitung verwendet werden kann.

Im Folgenden zeigen wir anhand eines Beispiels, wie Sie CompletableFuture verwenden, um zu benachrichtigen, wenn alle Elemente gemäß den oben genannten Schritten verarbeitet wurden.

Zuerst müssen wir eine Task-Klasse definieren, um die Verarbeitung asynchroner Aufgaben zu simulieren. Der Beispielcode lautet wie folgt:

import java.util.concurrent.CompletableFuture;

public class Task {
    public CompletableFuture<String> process(String element) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 模拟异步任务的处理过程
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return element.toUpperCase();
        });
        return future;
    }
}

Im obigen Code definiert die Task-Klasse eine Prozessmethode, um jedes Element zu verarbeiten und ein CompletableFuture-Objekt zurückzugeben. In dieser Methode verwenden wir die Methode CompletableFuture.supplyAsync, um die Verarbeitung einer asynchronen Aufgabe zu simulieren, das Element in Großbuchstaben umzuwandeln und zurückzugeben. Um den zeitaufwändigen Prozess einer asynchronen Aufgabe zu simulieren, haben wir gleichzeitig der Aufgabe einen Ruhezustand von 1 Sekunde hinzugefügt.

Als nächstes definieren wir eine Main-Klasse und verwenden sie in Kombination mit der Task-Klasse und CompletableFuture, um zu benachrichtigen, wenn alle Elemente verarbeitet werden. Der Beispielcode lautet wie folgt:

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        List<String> elements = new ArrayList<>();
        elements.add("hello");
        elements.add("world");
        elements.add("java");

        Task task = new Task();
        List<CompletableFuture<String>> futures = new ArrayList<>();

        // 遍历每个元素，并将它们的处理结果封装成一个CompletableFuture对象
        for (String element : elements) {
            CompletableFuture<String> future = task.process(element);
            futures.add(future);
        }

        // 等待所有异步任务完成，将它们的处理结果打印出来
        CompletableFuture<Void> allFutures = CompletableFuture.allOf(futures.toArray(new CompletableFuture[futures.size()]));
        allFutures.thenRun(() -> {
            System.out.println("所有异步任务已完成：");

            for (CompletableFuture<String> future : futures) {
                try {
                    String result = future.get();
                    System.out.println(result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

Im obigen Code definieren wir eine Liste, um alle Elemente zu speichern, erstellen dann ein Task-Objekt, durchlaufen jedes Element und kapseln seine Verarbeitungsergebnisse in ein CompletableFuture-Objekt und speichern es dann in einer Liste . Als Nächstes verwenden wir die CompletableFuture.allOf-Methode, um auf den Abschluss aller asynchronen Aufgaben zu warten. Nachdem alle Aufgaben abgeschlossen sind, drucken wir die Verarbeitungsergebnisse aller Aufgaben über das von der allOf-Methode zurückgegebene CompletableFuture-Objekt aus.

Wenn wir das obige Programm ausführen, können wir die folgende Ausgabe sehen:

所有异步任务已完成：
HELLO
WORLD
JAVA

Die Ausführungsergebnisse des obigen Programms zeigen, dass alle asynchronen Aufgaben verarbeitet wurden und jedes Element in Großbuchstaben umgewandelt wurde. Gleichzeitig haben wir auch die Funktion zur Benachrichtigung, wenn alle Elemente verarbeitet sind, erfolgreich implementiert.

Zusammenfassend lautet die Methode zur Verwendung von CompletableFuture zur Benachrichtigung, wenn alle Elemente verarbeitet sind:

1. Erstellen Sie mehrere CompletableFuture-Objekte, um verschiedene Elemente zu verarbeiten.
2. Rufen Sie die CompletableFuture.allOf-Methode auf, übergeben Sie alle CompletableFuture-Objekte als Parameter und warten Sie, bis alle asynchronen Aufgaben abgeschlossen sind.
3. Nachdem alle asynchronen Aufgaben abgeschlossen sind, gibt die allOf-Methode ein neues CompletableFuture-Objekt zurück, das für die nächste Verarbeitung verwendet werden kann.

Im Allgemeinen ist CompletableFuture ein sehr praktisches asynchrones Programmiertool, das uns dabei helfen kann, mehrere asynchrone Aufgaben zusammenzufassen und zu benachrichtigen, wenn alle Aufgaben abgeschlossen sind. In der tatsächlichen Entwicklung können wir CompletableFuture besser verwenden, um die Code-Parallelität und Ausführungseffizienz basierend auf der oben genannten Implementierungsmethode und tatsächlichen Geschäftsszenarien zu verbessern.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie CompletableFuture in Java, um zu benachrichtigen, wenn alle Elemente verarbeitet werden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!