Comment utiliser la fonction CompletableFuture en Java pour la programmation asynchrone-javaDidacticiel-php.cn

Alors que les systèmes informatiques modernes deviennent de plus en plus complexes et volumineux, les performances de concurrence sont devenues un outil nécessaire pour résoudre des problèmes pratiques. Les méthodes de programmation synchrone traditionnelles ne peuvent plus répondre aux besoins des systèmes complexes. La programmation asynchrone est devenue un outil important permettant aux programmeurs modernes de développer des programmes hautes performances. CompleteableFuture introduit dans Java 8 est un mécanisme puissant de programmation asynchrone, qui peut grandement simplifier la complexité de la programmation asynchrone et améliorer la lisibilité et la maintenabilité du code. Cet article détaillera les concepts de base de CompletableFuture, la création et l'utilisation de tâches asynchrones, et comment gérer les résultats des tâches asynchrones.

CompletableFuture Présentation

CompletableFuture est une classe qui implémente l'interface Future. Il s'agit d'un nouvel outil de programmation asynchrone fourni par Java 8 pour exprimer les opérations asynchrones et traiter les résultats des opérations. Différent de l'interface Future, CompletableFuture fournit des outils plus puissants pour mieux exprimer les résultats des opérations asynchrones. La classe CompletableFuture prend en charge le chaînage de plusieurs opérations asynchrones pour former une chaîne d'opérations asynchrones en streaming, similaire à Observable dans le framework RxJava et AsyncTask dans Android.

Avec CompletableFuture, les développeurs peuvent facilement créer une logique de programmation asynchrone sans avoir à prendre en compte de nombreux détails de threading et de verrouillage. L'utilisation de CompletableFuture est également très simple et claire. Ils modifient la façon dont la programmation asynchrone est implémentée, réduisent les défauts de la programmation asynchrone basée sur le rappel et améliorent la lisibilité et la maintenabilité du code.

Utilisation de base

L'utilisation de base de CompletableFuture est de créer une chaîne d'opérations asynchrones. Vous pouvez utiliser les méthodes thenApplyAsync, thenComposeAsync, thenCombineAsync et thenAcceptAsync pour relier les opérations asynchrones entre elles. La méthode thenApplyAsync est utilisée pour appliquer un foncteur (fonction) à un autre résultat asynchrone pour créer une nouvelle tâche asynchrone ; la méthode thenComposeAsync est utilisée pour mapper et lier le résultat d'une opération asynchrone à une autre tâche asynchrone ; la méthode thenCombineAsync est utilisée pour combiner ; les résultats de deux opérations asynchrones et créer une nouvelle opération asynchrone ; la méthode thenAcceptAsync est utilisée pour consommer un résultat asynchrone.

Ce qui suit est un exemple simple montrant le modèle de programmation asynchrone de base :

// 异步执行任务1
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");

// 异步执行任务2，并在任务1完成之后执行
CompletableFuture<String> future2 = future1.thenApplyAsync(result -> result + " World");

// 等待任务2执行完成，并处理结果
future2.thenAcceptAsync(result -> System.out.println(result));

Copier après la connexion

Ce code montre comment utiliser CompletableFuture pour créer un modèle de programmation asynchrone simple et puissant. chaîne d’opération. Tout d'abord, utilisez la méthode supplyAsync pour exécuter la tâche 1 de manière asynchrone. Cette méthode convertira une tâche synchrone en tâche asynchrone. Utilisez ensuite la méthode thenApplyAsync pour concaténer le résultat de la tâche 1 (« Bonjour ») avec la chaîne « Monde » et créez un nouvel objet chaîne qui représente une carte des résultats. Enfin, utilisez la méthode thenAcceptAsync pour traiter le résultat et l'imprimer. Cet exemple est très simple, mais il démontre les fonctionnalités de base de CompletableFuture, en particulier les capacités de programmation en chaîne et de programmation asynchrone.

Trois états d'opérations asynchrones

CompletableFuture a trois états, à savoir :

Incomplet ) : CompleteableFuture n'a pas encore défini les résultats pertinents. Par exemple, la tâche asynchrone n'a pas commencé à s'exécuter, la tâche asynchrone est en cours ou la tâche asynchrone a été exécutée mais n'est pas terminée.
Completed Exceptionnellement : CompleteableFuture a rencontré une exception lors de l'exécution, ce qui a empêché l'opération de se terminer. Le type d'exception est déterminé par le type d'exception défini en appelant la méthode completeExceptionally.
Completed Normalement : CompletableFuture a été terminé et le résultat a été renvoyé avec succès. Le type du résultat est déterminé par le type de paramètre passé en appelant la méthode complete ou completeAsync.

Tout objet CompletableFuture n'a qu'un seul état d'achèvement ou d'exception et passera de l'état inachevé à un état final. Vous pouvez utiliser la méthode isDone pour vérifier si un CompletableFuture est terminé. Par exemple : future.isDone().

Autres façons d'explorer CompletableFuture

CompletableFuture propose de nombreuses méthodes pour retarder l'exécution d'une tâche asynchrone et traiter ses résultats. Voici quelques-unes des principales méthodes CompletableFuture :

Runnable 包装器：runAsync 和 supplyAsync 是 CompletableFuture 运行异步任务的最简单的方式。
转换函数：我们可以通过使用 thenApply 方法来将一个异步操作的结果转化为另一个异步操作的参数。这也被称为异步映射。同样，使用 thenAccept 方法将一个异步结果作为消耗者。
Bi Function：thenCombine 方法将两个 CompletableFuture 对象组合在一起，同时为它们提供一个组合函数。
异常处理：当 Future 对象抛出异常时，我们可以使用 exceptionally 方法指定如何处理异常。另外，使用 handle 方法还可以处理正常的结果和异常的情况。
组合多个结果：使用 allOf 和 anyOf 方法处理多个异步操作的结果。其中 allOf 则等待所有异步操作完成，而 anyOf 仅需等待其中任意一个异步操作完成。

案例演示

我们来看一个更加复杂的例子，该例子将涉及到 CompletableFuture 的多种使用模式：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureDemo {

   public static void main(String args[]) throws InterruptedException, ExecutionException {

      // 创建异步任务1
      CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 2 + 3);

      // 创建异步任务2
      CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 3 * 4);

      // 组合异步任务1和异步任务2，使用BiFunction对象作为组合函数
      CompletableFuture<Integer> future3 = future1.thenCombineAsync(future2, (result1, result2) -> result1 * result2);

      // 创建异步任务3
      CompletableFuture<Integer> future4 = CompletableFuture.supplyAsync(() -> 2 + 7);

      // 组合异步任务1和异步任务3，使用Function类型的函数
      CompletableFuture<Integer> future5 = future1.thenComposeAsync(result -> CompletableFuture.supplyAsync(() -> result + 5));

      // 组合异步任务1、异步任务2和异步任务3，使用组合函数，返回类型为Void
      CompletableFuture<Void> future6 = CompletableFuture.allOf(future1, future2, future4).thenAcceptAsync((Void) -> {
         try {
            System.out.println("The result of future1 is: " + future1.get());
            System.out.println("The result of future2 is: " + future2.get());
            System.out.println("The result of future4 is: " + future4.get());
         } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
         }
      });

      // 等待所有异步任务执行完毕
      CompletableFuture.allOf(future3, future5, future6).join();
   }
}

Copier après la connexion

这段代码展示了 CompletableFutures 几种常用方法：suplyAsync、thenCombineAsync、thenComposeAsync和acceptAsync、allOf、isDone、join、get 和其他一些方法。我们首先定义了三个不同的 CompletableFuture 对象，根据不同的函数来完成，然后使用 thenCombineAsync 方法将这两个对象组合成一个对象。我们还使用 thenComposeAsync 构建了另一个异步结果，从这两个对象中获取了一些信息。最后，我们使用 allOf 方法来组合三个异步事件并在这三个异步操作完成后将它们组合在一个 Void 异步操作中，并使用 thenAcceptAsync 接受它们的值并将其打印到控制台上。

异步编程实践

异步编程是一项复杂的任务，有很多复杂性，需要更多的时间和经验来正确地完成。我们需要明确异步编程的目的，并准确掌握 CompletableFuture 机制，才能写出简洁、精简、易维护的代码。

异步编程的另一个好处是提高应用程序的性能和吞吐量，因为我们可以为多个 CPU 核心优化和并发运行任务。然而，它也有一定的成本，包括更复杂的代码、需要加锁的数据结构和其他潜在的性能问题。但是，使用 CompletableFuture 进行异步编程，可以使代码更具可读性和可维护性，并减少程序员编写出还原异步操作的代码的负担。异步编程虽然存在挑战，但对于开发高性能应用程序至关重要。

结论

这篇文章介绍了 CompletableFuture 和其在 Java 异步编程中的应用。CompletableFuture 类是一种强大的异步编程工具，可以帮助开发人员优雅地解决异步问题。虽然异步编程有一定的复杂性，但是通过理解 CompletableFuture 的基础和高级特性，我们可以优化代码并提高我们应用程序的性能。

总结起来，CompletableFuture 是 Java 8 提供的一种强大的异步编程工具，可用于解决异步操作的问题。CompletableFuture 可以通过链式编程来组成异步操作链，在提高效率的同时也为程序提供了更加优雅的代码实现方案。尽管异步编程带来了一些复杂性，需要开发人员在编写代码时更加小心，但当正确地使用 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!