Cara menggunakan fungsi CompletableFuture dalam Java untuk pengaturcaraan tak segerak

Apabila sistem komputer moden menjadi semakin kompleks dan besar, prestasi serentak telah menjadi alat yang diperlukan untuk menyelesaikan masalah praktikal. Kaedah pengaturcaraan segerak tradisional tidak lagi dapat memenuhi keperluan sistem yang kompleks telah menjadi alat penting untuk pengaturcara moden untuk membangunkan program berprestasi tinggi. CompletableFuture yang diperkenalkan dalam Java 8 ialah mekanisme yang berkuasa untuk pengaturcaraan tak segerak, yang boleh memudahkan kerumitan pengaturcaraan tak segerak dan meningkatkan kebolehbacaan dan kebolehselenggaraan kod. Artikel ini akan memperincikan konsep asas CompletableFuture, membina dan menggunakan tugas tak segerak, dan cara mengendalikan hasil tugas tak segerak.

CompletableFuture Overview

CompletableFuture ialah kelas yang melaksanakan antara muka Masa Depan Ia adalah alat pengaturcaraan tak segerak baharu yang disediakan oleh Java 8 untuk menyatakan operasi tak segerak dan hasil operasi pemprosesan. Berbeza daripada antara muka Masa Depan, CompletableFuture menyediakan alat yang lebih berkuasa untuk menyatakan hasil operasi tak segerak dengan lebih baik. Kelas CompletableFuture menyokong rantaian berbilang operasi tak segerak untuk membentuk rantaian operasi tak segerak penstriman, serupa dengan Observable dalam rangka kerja RxJava dan AsyncTask dalam Android.

Dengan CompletableFuture, pembangun boleh membina logik pengaturcaraan tak segerak dengan mudah tanpa perlu mempertimbangkan banyak butiran benang dan mengunci. Penggunaan CompletableFuture juga sangat mudah dan jelas Mereka mengubah cara pengaturcaraan tak segerak dilaksanakan, mengurangkan kecacatan pengaturcaraan tak segerak berasaskan panggilan balik, dan meningkatkan kebolehbacaan dan kebolehselenggaraan kod.

Penggunaan asas

Penggunaan asas CompletableFuture adalah untuk membina rantaian operasi tak segerak Anda boleh menggunakan kaedah thenApplyAsync, thenComposeAsync, thenCombineAsync dan thenAcceptAsync untuk memautkan operasi tak segerak. Kaedah thenApplyAsync digunakan untuk menggunakan functor (fungsi) pada hasil tak segerak yang lain untuk mencipta tugas tak segerak baharu kaedah thenComposeAsync digunakan untuk memetakan dan memautkan hasil operasi tak segerak kepada tugas tak segerak yang lain, kaedah thenCombineAsync digunakan untuk Gabung; hasil daripada dua operasi tak segerak dan buat operasi tak segerak baharu; kaedah thenAcceptAsync digunakan untuk menggunakan hasil tak segerak.

Berikut ialah contoh mudah yang menunjukkan corak pengaturcaraan tak segerak asas:

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

Kod ini menunjukkan cara menggunakan CompletableFuture untuk membina model pengaturcaraan tak segerak yang ringkas dan berkuasa untuk membentuk rantaian operasi tak segerak. Pertama, gunakan kaedah supplyAsync untuk melaksanakan tugasan 1 secara tak segerak. Kemudian gunakan kaedah thenApplyAsync untuk menggabungkan hasil tugasan 1 ("Hello") dengan rentetan "World" dan bina objek rentetan baharu yang mewakili peta hasil. Akhir sekali, gunakan kaedah thenAcceptAsync untuk memproses hasilnya dan mencetaknya. Contoh ini sangat mudah, tetapi ia menunjukkan ciri asas CompletableFuture, terutamanya keupayaan pengaturcaraan rantai dan pengaturcaraan tak segerak.

Tiga keadaan operasi tak segerak

CompletableFuture mempunyai tiga keadaan, iaitu:

• Uncompleted: CompletableFuture masih belum menetapkan keputusan yang berkaitan. Sebagai contoh, tugas tak segerak belum mula berjalan, tugas tak segerak sedang berjalan atau tugas tak segerak telah dijalankan tetapi tidak selesai.
• Selesai Luar Biasa: CompletableFuture menghadapi pengecualian semasa masa jalan, menyebabkan operasi tidak selesai. Jenis pengecualian ditentukan oleh jenis Pengecualian yang ditetapkan dengan memanggil kaedah completeExceptionally.
• Completed (Completed Normally): CompletableFuture telah selesai dan hasilnya berjaya dikembalikan. Jenis hasil ditentukan oleh jenis parameter yang diluluskan dengan memanggil kaedah complete atau completeAsync.

Sebarang objek CompletableFuture hanya mempunyai satu keadaan lengkap atau pengecualian, dan akan beralih daripada keadaan belum selesai kepada keadaan akhir. Anda boleh menggunakan kaedah isDone untuk menyemak sama ada CompletableFuture telah selesai. Contohnya: future.isDone().

Teroka kaedah CompletableFuture dengan lebih lanjut

CompletableFuture menyediakan banyak kaedah untuk menangguhkan pelaksanaan tugas tak segerak dan memproses keputusannya. Berikut adalah beberapa kaedah CompletableFuture utama:

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

Atas ialah kandungan terperinci Cara menggunakan fungsi CompletableFuture dalam Java untuk pengaturcaraan tak segerak. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!