So verwenden Sie die CompletableFuture-Funktion in Java für die asynchrone Programmierung

Da moderne Computersysteme immer komplexer und größer werden, ist die Parallelitätsleistung zu einem notwendigen Werkzeug zur Lösung praktischer Probleme geworden. Herkömmliche Methoden der synchronen Programmierung können den Anforderungen komplexer Systeme nicht mehr gerecht werden. Die asynchrone Programmierung ist für moderne Programmierer zu einem wichtigen Werkzeug zur Entwicklung leistungsstarker Programme geworden. CompletableFuture wurde in Java 8 eingeführt und ist ein leistungsstarker Mechanismus für die asynchrone Programmierung, der die Komplexität der asynchronen Programmierung erheblich vereinfachen und die Lesbarkeit und Wartbarkeit des Codes verbessern kann. In diesem Artikel werden die Grundkonzepte von CompletableFuture, das Erstellen und Verwenden asynchroner Aufgaben sowie der Umgang mit den Ergebnissen asynchroner Aufgaben detailliert erläutert.

CompletableFuture-Übersicht

CompletableFuture ist eine Klasse, die die Future-Schnittstelle implementiert. Es handelt sich um ein neues asynchrones Programmiertool, das von Java 8 zum Ausdrucken asynchroner Operationen und zum Verarbeiten von Operationsergebnissen bereitgestellt wird. Im Gegensatz zur Future-Schnittstelle bietet CompletableFuture leistungsfähigere Tools, um die Ergebnisse asynchroner Vorgänge besser auszudrücken. Die CompletableFuture-Klasse unterstützt die Verkettung mehrerer asynchroner Vorgänge, um eine asynchrone Streaming-Vorgangskette zu bilden, ähnlich wie Observable im RxJava-Framework und AsyncTask in Android.

Mit CompletableFuture können Entwickler problemlos asynchrone Programmierlogik erstellen, ohne viele Threading- und Sperrdetails berücksichtigen zu müssen. Die Verwendung von CompletableFuture ist ebenfalls sehr einfach und klar. Sie ändern die Art und Weise, wie asynchrone Programmierung implementiert wird, reduzieren die Mängel der rückrufbasierten asynchronen Programmierung und verbessern die Lesbarkeit und Wartbarkeit des Codes.

Grundlegende Verwendung

Die grundlegende Verwendung von CompletableFuture besteht darin, eine asynchrone Operationskette aufzubauen. Sie können die Methoden thenApplyAsync, thenComposeAsync, thenCombineAsync und thenAcceptAsync verwenden, um asynchrone Vorgänge miteinander zu verknüpfen. Die Methode thenApplyAsync wird verwendet, um einen Funktor (Funktion) auf ein anderes asynchrones Ergebnis anzuwenden, um eine neue asynchrone Aufgabe zu erstellen. Die Methode thenComposeAsync wird verwendet, um das Ergebnis einer asynchronen Operation einer anderen asynchronen Aufgabe zuzuordnen und zu verknüpfen Die Ergebnisse zweier asynchroner Vorgänge werden verarbeitet und eine neue asynchrone Operation erstellt. Die Methode thenAcceptAsync wird verwendet, um ein asynchrones Ergebnis zu verarbeiten.

Das Folgende ist ein einfaches Beispiel, das das grundlegende asynchrone Programmiermuster zeigt:

// 异步执行任务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));

Dieser Code zeigt, wie man CompletableFuture verwendet, um ein einfaches und leistungsstarkes asynchrones Programmiermodell zu erstellen, um eine Kette asynchroner Vorgänge zu bilden. Verwenden Sie zunächst die Methode „supplyAsync“, um Aufgabe 1 asynchron auszuführen. Diese Methode konvertiert eine synchrone Aufgabe in eine asynchrone Aufgabe. Verwenden Sie dann die Methode thenApplyAsync, um das Ergebnis von Aufgabe 1 („Hello“) mit der Zeichenfolge „World“ zu verketten und ein neues Zeichenfolgenobjekt zu erstellen, das eine Karte der Ergebnisse darstellt. Verwenden Sie abschließend die Methode thenAcceptAsync, um das Ergebnis zu verarbeiten und auszudrucken. Dieses Beispiel ist sehr einfach, demonstriert jedoch die Grundfunktionen von CompletableFuture, insbesondere die Fähigkeiten der Kettenprogrammierung und der asynchronen Programmierung.

Drei Zustände asynchroner Vorgänge

CompletableFuture hat drei Zustände:

• Unvollständig: CompletableFuture hat die relevanten Ergebnisse noch nicht festgelegt. Beispielsweise hat die Ausführung der asynchronen Aufgabe noch nicht begonnen, die asynchrone Aufgabe wird gerade ausgeführt oder die asynchrone Aufgabe wurde ausgeführt, aber noch nicht abgeschlossen.
• Ausnahmsweise abgeschlossen: CompletableFuture hat während der Laufzeit eine Ausnahme festgestellt, die dazu führte, dass der Vorgang nicht abgeschlossen wurde. Der Typ der Ausnahme wird durch den Ausnahmetyp bestimmt, der durch Aufrufen der Methode „completeExceptionally“ festgelegt wird.
• Abgeschlossen (normalerweise abgeschlossen): CompletableFuture wurde abgeschlossen und das Ergebnis wurde erfolgreich zurückgegeben. Der Typ des Ergebnisses wird durch den Parametertyp bestimmt, der beim Aufruf der Methode „complete“ oder „completeAsync“ übergeben wird.

Jedes CompletableFuture-Objekt hat nur einen Abschluss- oder Ausnahmezustand und wechselt vom unvollständigen Zustand in den Endzustand. Mit der Methode isDone können Sie prüfen, ob ein CompletableFuture abgeschlossen wurde. Zum Beispiel: future.isDone().

Erkunden Sie die Methoden von CompletableFuture weiter

CompletableFuture bietet viele Methoden, um die Ausführung einer asynchronen Aufgabe zu verzögern und ihre Ergebnisse zu verarbeiten. Hier sind einige der wichtigsten CompletableFuture-Methoden:

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

这段代码展示了 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 时，它可以帮助我们轻松地实现高效率、可维护和高质量的代码。

Das obige ist der detaillierte Inhalt vonSo verwenden Sie die CompletableFuture-Funktion in Java für die asynchrone Programmierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!