Gestion du multithreading en Java avec Completel Future

1. Comprendre un avenir réalisable

CompletableFuture fait partie du package java.util.concurrent et offre un moyen d'écrire du code asynchrone et non bloquant d'une manière plus lisible et maintenable. Il représente un résultat futur d'un calcul asynchrone.

1.1 Créer un avenir simple et complet

Pour commencer avec CompletableFuture , vous pouvez créer une simple tâche asynchrone. Voici un exemple :

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() exécute une tâche de manière asynchrone.
• future.join() bloque le thread principal jusqu'à ce que la tâche soit terminée.

Résultat de la démo :

Running asynchronously...
Task completed.

1.2 Utilisation de CompletableFuture avec les résultats

Vous pouvez également utiliser CompletableFuture pour renvoyer les résultats de tâches asynchrones :

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() est utilisé pour les tâches qui renvoient un résultat.
• thenAccept() traite le résultat une fois le calcul terminé.

Résultat de la démo :

The result is: 25

2. Combiner plusieurs CompleteableFutures

La gestion de plusieurs tâches asynchrones est un cas d'utilisation courant. CompleteableFuture propose plusieurs méthodes pour combiner des contrats à terme.

2.1 Combiner Futures avec thenCombine

Vous pouvez combiner les résultats de plusieurs CompletableFutures :

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 () combine les résultats de deux futurs.
• Le résultat combiné est traité à l'aide de thenAccept ().

Résultat de la démo :

Combined result: 15

2.2 Gestion de plusieurs contrats à terme avec allOf

Lorsque vous devez attendre la fin de plusieurs futurs, utilisez 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() attend que tous les futurs donnés soient terminés.
• join() garantit que le thread principal attend que toutes les tâches soient terminées.

Résultat de la démo :

All tasks completed.

3. Gestion des erreurs avec CompletableFuture

La gestion des erreurs est essentielle dans la programmation asynchrone. CompleteableFuture fournit des méthodes pour gérer les exceptions.

3.1 Gestion des exceptions avec exceptionnellement

Utilisez exceptionnellement () pour gérer les exceptions dans les tâches asynchrones :

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

• exceptionnellement () intercepte et gère les exceptions.
• Il vous permet de fournir un résultat de secours ou de gérer l'erreur.

Résultat de la démo :

Exception occurred: Something went wrong!

4. Avantages et inconvénients de CompleteableFuture

4.1 Avantages

• Exécution asynchrone : Gère efficacement les tâches qui s'exécutent simultanément sans bloquer le thread principal.
• Lisibilité améliorée : Fournit un moyen plus lisible et maintenable de gérer le code asynchrone par rapport aux approches de rappel traditionnelles.
• API riche : offre une variété de méthodes pour combiner, gérer et composer plusieurs futurs.

4.2 Inconvénients

• Complexité : Bien que puissant, CompletableFuture peut introduire de la complexité dans la gestion et le débogage du code asynchrone.
• Gestion des exceptions : La gestion des exceptions peut parfois être délicate, en particulier dans les scénarios complexes comportant plusieurs étapes.

5. Conclusion

Dans ce guide, nous avons exploré comment CompletableFuture peut être utilisé pour gérer les requêtes simultanées en Java. De la création de tâches asynchrones simples à la combinaison de plusieurs futurs et à la gestion des erreurs, CompletableFuture offre une approche robuste et flexible de la programmation asynchrone.

Si vous avez des questions ou avez besoin d'aide supplémentaire, n'hésitez pas à laisser un commentaire ci-dessous. Je serais heureux de vous aider !

Lisez plus d'articles sur : Gestion du multithreading en Java avec Completable Future

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!