Comment utiliser CompletableFuture en Java pour avertir lorsque tous les éléments sont traités

CompletableFuture en Java est un outil de programmation asynchrone très puissant. Il peut nous aider à effectuer la livraison, le traitement, la notification et d'autres opérations de tâches pendant le traitement asynchrone, simplifiant considérablement la difficulté de la programmation asynchrone. Lors de l'utilisation de CompletableFuture pour le traitement asynchrone, il existe un scénario dans lequel il est nécessaire de notifier une fois que tous les éléments sont traités. Cet article explique comment utiliser CompletableFuture en Java pour implémenter ce scénario.

Tout d'abord, vous devez comprendre les concepts de base et l'utilisation de CompletableFuture. CompletableFuture est une nouvelle classe de Java 8 qui fournit un moyen de traiter les résultats lors de l'exécution d'opérations de manière asynchrone. Cela nous permet de combiner plusieurs opérations asynchrones en une opération plus complexe et d'attendre la fin de toutes les opérations asynchrones avant de passer à l'étape suivante.

Dans le scénario de notification lorsque tous les éléments sont traités, nous devons utiliser la méthode CompletableFuture : allOf. Cette méthode peut combiner plusieurs objets CompletableFuture et renvoyer un nouvel objet CompletableFuture après avoir attendu que les tâches asynchrones de tous les objets soient terminées.

Les étapes de base de l'utilisation de la méthode allOf sont les suivantes :

1. Créez plusieurs objets CompletableFuture pour traiter différents éléments.
2. Appelez la méthode CompletableFuture.allOf, transmettez tous les objets CompletableFuture en tant que paramètres et attendez que toutes les tâches asynchrones soient terminées.
3. Une fois toutes les tâches asynchrones terminées, la méthode allOf renverra un nouvel objet CompletableFuture, qui pourra être utilisé pour la prochaine étape du traitement.

Ci-dessous, nous utilisons un exemple pour montrer comment utiliser CompletableFuture pour notifier lorsque tous les éléments sont traités selon les étapes ci-dessus.

Tout d'abord, nous devons définir une classe Task pour simuler le traitement des tâches asynchrones. L'exemple de code est le suivant :

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;
    }
}

Dans le code ci-dessus, la classe Task définit une méthode de processus pour traiter chaque élément et renvoyer un objet CompletableFuture. Dans cette méthode, nous utilisons la méthode CompletableFuture.supplyAsync pour simuler le traitement d'une tâche asynchrone, convertir l'élément en majuscule et le renvoyer. Dans le même temps, afin de simuler le processus fastidieux d'une tâche asynchrone, nous avons ajouté une seconde de sommeil à la tâche.

Ensuite, nous définissons une classe Main et l'utilisons en combinaison avec la classe Task et CompletableFuture pour avertir lorsque tous les éléments sont traités. L'exemple de code est le suivant :

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();
                }
            }
        });
    }
}

Dans le code ci-dessus, nous définissons une liste pour enregistrer tous les éléments, puis créons un objet Task, parcourons chaque élément et encapsulons leurs résultats de traitement dans un objet CompletableFuture, enregistrez ces objets dans une liste. Ensuite, nous utilisons la méthode CompletableFuture.allOf pour attendre que toutes les tâches asynchrones soient terminées, et une fois toutes les tâches terminées, imprimons les résultats du traitement de toutes les tâches via l'objet CompletableFuture renvoyé par la méthode allOf.

Lorsque nous exécutons le programme ci-dessus, nous pouvons voir le résultat suivant :

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

Les résultats d'exécution du programme ci-dessus montrent que toutes les tâches asynchrones ont été traitées et que chaque élément a été converti est devenu capitalisé. Dans le même temps, nous avons également implémenté avec succès la fonction de notification lorsque tous les éléments sont traités.

Pour résumer, la méthode d'utilisation de CompletableFuture pour notifier lorsque tous les éléments sont traités est la suivante :

1. Créez plusieurs objets CompletableFuture pour traiter différents éléments.
2. Appelez la méthode CompletableFuture.allOf, transmettez tous les objets CompletableFuture en tant que paramètres et attendez que toutes les tâches asynchrones soient terminées.
3. Une fois toutes les tâches asynchrones terminées, la méthode allOf renverra un nouvel objet CompletableFuture, qui pourra être utilisé pour la prochaine étape du traitement.

En général, CompletableFuture est un outil de programmation asynchrone très pratique qui peut nous aider à combiner plusieurs tâches asynchrones ensemble et à avertir lorsque toutes les tâches sont terminées. Dans le développement réel, nous pouvons mieux utiliser CompletableFuture pour améliorer la concurrence du code et l'efficacité d'exécution en fonction de la méthode de mise en œuvre ci-dessus et des scénarios commerciaux réels.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!