Qu'est-ce que CompletableFuture ?

CompletableFuture en Java 8+ représente une extension du modèle Future, ajoutant des capacités de programmation asynchrone et de composition de tâches.

Il implémente les interfaces CompletionStage et Future. CompletionStage définit le contrat pour l'exécution asynchrone et la composition d'étapes de calcul.

Caractéristiques clés :

• Opérations non bloquantes : Permet d'exécuter des tâches de manière asynchrone sans bloquer le fil principal.
• Composition : Fournit une API riche pour lier et combiner les résultats de plusieurs opérations asynchrones.
• Gestion des exceptions : Mécanismes intégrés pour gérer les erreurs dans les flux asynchrones.
• Création : Il est possible de créer des CompletableFuture complétés, non complétés ou erronés.
• Dépendances : Permet de créer des chaînes de tâches dépendantes, où l'exécution de l'une dépend de la fin de l'autre.
• Exécution parallèle : Méthodes comme allOf et anyOf pour exécuter plusieurs tâches en parallèle.

Exemples d'utilisation :

1. Création et complétion :

   // Créer un CompletableFuture complété
   CompletableFuture<String> completedFuture = CompletableFuture.completedFuture("Hello");
   
   // Créer un CompletableFuture non complété et le compléter plus tard
   CompletableFuture<String> future = new CompletableFuture<>();
   // ... effectuer un travail asynchrone ...
   future.complete("Done");
   // Ou en cas d'erreur
   // future.completeExceptionally(new RuntimeException("Erreur"));
   

2. Exécuter une tâche asynchrone :

   CompletableFuture<String> asyncFuture = CompletableFuture.supplyAsync(() -> {
       // Travail asynchrone (par exemple, lecture d'un fichier, requête réseau)
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           throw new IllegalStateException(e);
       }
       return "Résultat Asynchrone";
   });
   

3. Composition avec thenApply :

   CompletableFuture<Integer> result = CompletableFuture.supplyAsync(() -> 10)
       .thenApply(x -> x * 2); // Le résultat de l'étape précédente est passé à la fonction
   

4. Composition avec thenCombine :

   CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 10);
   CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 20);
   
   CompletableFuture<Integer> combinedFuture = future1.thenCombine(future2, (res1, res2) -> res1 + res2); // Combine les résultats de deux CompletableFuture
   

5. Gestion de la fin avec thenAccept :

   CompletableFuture.supplyAsync(() -> "Résultat final")
       .thenAccept(result -> System.out.println("Tâche terminée avec le résultat : " + result)); // Effectue une action après la fin sans retourner de valeur
   

6. Gestion des exceptions avec exceptionally :

   CompletableFuture<String> futureWithException = CompletableFuture.supplyAsync(() -> {
       throw new RuntimeException("Quelque chose a mal tourné");
   }).exceptionally(ex -> {
       System.err.println("Erreur survenue : " + ex.getMessage());
       return "Valeur par défaut"; // Retourne une valeur par défaut en cas d'erreur
   });
   

CompletableFuture simplifie considérablement l'écriture de code asynchrone et non bloquant en Java, le rendant plus lisible et maintenable par rapport aux callbacks traditionnels ou aux appels bloquants Future.get().