Comment utiliser CompletableFuture pour la programmation asynchrone et le contrôle de concurrence dans Java 9

Comment utiliser CompletableFuture pour implémenter la programmation asynchrone et le contrôle de concurrence dans Java 9

Introduction :
Avec la demande croissante de hautes performances et de haute concurrence dans les applications modernes, la programmation asynchrone et le contrôle de concurrence sont devenus des problèmes courants dans le développement. La classe CompletableFuture introduite dans Java 9 fournit un mécanisme puissant pour gérer les opérations asynchrones et fournit un moyen simple et élégant d'implémenter le contrôle de concurrence. Cet article présentera les concepts de base de CompletableFuture dans Java 9 et fournira des exemples de code pour montrer comment utiliser CompletableFuture pour implémenter la programmation asynchrone et le contrôle de concurrence.

1. Introduction à CompletableFuture

CompletableFuture est un complément au mécanisme de programmation asynchrone introduit dans Java 8. C'est une classe qui implémente les interfaces Future et CompletionStage. L'interface Future est utilisée pour représenter le résultat d'une tâche asynchrone qui peut ne pas être terminée, tandis que l'interface CompletionStage est utilisée pour exprimer un calcul qui peut être effectué de manière asynchrone (y compris le déclenchement d'opérations et le renvoi de résultats), ainsi que les opérations ultérieures qui peuvent être déclenché une fois le calcul terminé. La classe CompletableFuture fournit un moyen simplifié d'utiliser ces interfaces et offre des fonctionnalités plus puissantes pour gérer les opérations asynchrones.

2. Exemple d'utilisation de base

1. Création d'un objet CompletableFuture

Tout d'abord, nous devons créer un objet CompletableFuture pour représenter le résultat d'un calcul asynchrone. La classe CompletableFuture fournit une variété de méthodes statiques pour créer de tels objets, tels quecompleteFuture, supplyAsync, etc. Voici un exemple de code :

CompletableFuture<String> future = CompletableFuture.completedFuture("Hello, CompletableFuture!");

Dans le code ci-dessus, nous utilisons la méthodecompleteFuture pour créer un objet CompletableFuture terminé et lui transmettre une chaîne comme résultat du calcul.

2. Déclencher le calcul asynchrone

Ensuite, nous devons déclencher un calcul asynchrone et l'associer à l'objet CompletableFuture créé à l'étape précédente. La classe CompletableFuture fournit deux méthodes pour y parvenir, à savoir runAsync et supplyAsync. Le premier est utilisé pour effectuer une opération asynchrone qui ne renvoie pas de résultat, tandis que le second est utilisé pour effectuer une opération asynchrone qui renvoie un résultat. Voici un exemple de code :

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 异步计算，返回一个整数结果
    return 42;
});

Dans le code ci-dessus, nous utilisons la méthode supplyAsync pour créer un calcul exécuté de manière asynchrone qui renverra un résultat entier.

3. Traitement des résultats du calcul asynchrone

Une fois le calcul asynchrone terminé, nous pouvons traiter les résultats calculés en appelant les méthodes de l'objet CompletableFuture. La classe CompletableFuture fournit une variété de méthodes pour traiter les résultats, telles que thenApply, thenAccept, etc. Voici un exemple de code :

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 异步计算，返回一个整数结果
    return 42;
});
future.thenApply(result -> {
    // 处理结果并返回一个新的结果
    return result * 2;
})
.thenAccept(result -> {
    // 处理最终结果
    System.out.println("Final result: " + result);
});

Dans le code ci-dessus, nous appelons la méthode thenApply pour traiter le résultat une fois le calcul asynchrone terminé et renvoyer un nouveau résultat. Ensuite, nous avons appelé la méthode thenAccept pour traiter le résultat final et l'imprimer.

3. Exemple de contrôle de concurrence

En plus de la programmation asynchrone, CompletableFuture fournit également quelques méthodes pour implémenter le contrôle de concurrence. Les méthodes les plus couramment utilisées incluent : anyOf, allOf et join.

1. Méthode anyOf

La méthode anyOf est utilisée pour attendre la fin de l'un des multiples CompletableFutures. Il renverra un nouvel objet CompletableFuture qui évalue le résultat du premier objet CompletableFuture terminé. Voici un exemple de code :

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    // 异步计算1
    return 1;
});
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    // 异步计算2
    return 2;
});
CompletableFuture<Object> resultFuture = CompletableFuture.anyOf(future1, future2);
resultFuture.thenAccept(result -> {
    System.out.println("First result: " + result);
});

Dans le code ci-dessus, nous utilisons la méthode anyOf pour attendre que future1 ou future2 soit calculé et imprimons le résultat.

2. Méthode allOf

La méthode allOf est utilisée pour attendre la fin de tous les calculs dans plusieurs CompletableFutures. Il renverra un nouvel objet CompletableFuture, qui sera évalué à une valeur Void (nulle). Voici un exemple de code :

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    // 异步计算1
    return 1;
});
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    // 异步计算2
    return 2;
});
CompletableFuture<Void> resultFuture = CompletableFuture.allOf(future1, future2);
resultFuture.thenRun(() -> {
    System.out.println("All calculations are completed.");
});

Dans le code ci-dessus, nous utilisons la méthode allOf pour attendre que tous les calculs de future1 et future2 soient terminés et imprimons un message de fin.

3. méthode join

la méthode join est utilisée pour attendre le résultat du calcul d'un CompletableFuture et renvoyer le résultat. Si une exception se produit pendant le calcul, une exception sera levée. Voici un exemple de code :

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 异步计算，返回一个整数结果
    return 42;
});
int result = future.join();
System.out.println("Result: " + result);

Dans le code ci-dessus, nous utilisons la méthode join pour attendre que le calcul du futur soit terminé et obtenir son résultat.

Résumé :

Cet article présente les concepts de base de CompletableFuture dans Java 9 et donne quelques exemples de code pour montrer comment utiliser CompletableFuture pour implémenter la programmation asynchrone et le contrôle de concurrence. En utilisant CompletableFuture, nous pouvons gérer les opérations asynchrones de manière simple et élégante et obtenir un contrôle flexible des calculs simultanés. J'espère que ces exemples vous aideront à comprendre et à utiliser CompletableFuture.

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!