Minggu Ini Saya Belajar: CompletableFuture – Pendekatan Java untuk Pengaturcaraan Asynchronous

Minggu ini, saya menyelami Java's CompletableFuture.

Sebagai pembangun tindanan penuh dengan latar belakang bahagian hadapan, menangani tugas tak segerak merupakan bahagian yang tidak dapat dielakkan dalam peranan saya – permintaan rangkaian, pengiraan latar belakang dan seumpamanya. Di Java, CompletableFuture ialah alat yang berkuasa untuk mengendalikan tugasan ini sambil memastikan urutan utama responsif.

Niaga hadapan yang boleh dilengkapkan adalah untuk Java seperti Janji kepada JavaScript.

Jika anda biasa dengan JavaScript, anda mungkin dapat memahami konsep ini dengan membuat persamaan antara kedua-dua bahasa. Saya suka menganggap CompletableFuture sebagai Promise versi Java. Ia ialah kelas yang mewakili hasil akhirnya operasi tak segerak, sama ada keputusan itu berjaya atau gagal. Diperkenalkan dalam Java 8 sebagai sebahagian daripada pakej java.util.concurrent, ia merupakan cara yang berkesan untuk menulis kod tidak menyekat, dengan kaedah untuk operasi rantaian dan pengendalian ralat, sama seperti Promises.

Berikut ialah perbandingan pantas kedua-duanya:

// JavaScript Promise
fetchFromServer()
    .then(data => processData(data))
    .then(result => updateUI(result))
    .catch(error => handleError(error));

// Java CompletableFuture
CompletableFuture.supplyAsync(() -> fetchDataFromServer())
    .thenApply(data -> processData(data))
    .thenAccept(result -> updateUI(result))
    .exceptionally(error -> handleError(error));

Seperti yang digambarkan di atas, CompletableFuture menyediakan sintaks boleh rantai yang serupa yang membenarkan kod tak segerak yang bersih dan boleh dibaca.

Pertimbangkan senario di mana anda perlu mengambil data profil pengguna dan sejarah pesanan daripada dua titik akhir yang berasingan. Anda ingin mengelak daripada membekukan UI sementara menunggu permintaan ini selesai. Begini cara anda melaksanakannya menggunakan CompletableFuture:

CompletableFuture<User> profileFuture = CompletableFuture.supplyAsync(() -> {
    // Fetch user profile from a service
});

CompletableFuture<List<Order>> ordersFuture = CompletableFuture.supplyAsync(() -> {
    // Fetch user orders from another service
});

CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(profileFuture, ordersFuture);

combinedFuture.thenRun(() -> {
    User user = userFuture.join(); 
    List<Order> orders = ordersFuture.join(); 
    displayUserData(user, orders); 
});

Dalam contoh ini, kami mencetuskan dua permintaan tak segerak secara serentak dan menggunakan allOf untuk menunggu kedua-duanya selesai. Setelah selesai, kami mendapatkan semula keputusan dan mengemas kini UI dengan sewajarnya, semuanya tanpa menyekat urutan utama.

---

Peringkat Rantaian & Penyelesaian

CompletableFuture melaksanakan antara muka CompletionStage, yang menyediakan asas untuk operasi rantaian. Setiap kaedah thenApply, thenAccept dan serupa mengembalikan CompletionStage yang lain, membolehkan anda membuat saluran paip tak segerak yang kompleks.

Sama seperti cara kita boleh merantai janji dalam JavaScript apabila kita mempunyai urutan tugas tak segerak untuk dilaksanakan satu demi satu, kita boleh merantai tugasan dalam Masa Depan Lengkap untuk mencipta urutan operasi tak segerak bergantung tanpa jatuh ke dalam neraka panggil balik . Begini cara kami melakukannya:

CompletableFuture.supplyAsync(() -> "Hello")
    .thenApply(result -> result + ", CompletableFuture")
    .thenApply(result -> result + " in Java")
    .thenAccept(System.out::println);

Mengendalikan pengecualian

Di mana kita mempunyai .catch() pada objek Promise, kita mempunyai .exceptionally() pada Masa Depan yang Boleh Dilengkapkan. Kaedah ini mengendalikan pengecualian yang mungkin berlaku semasa pemprosesan tak segerak:

CompletableFuture.supplyAsync(() -> {
    if (true) {
        throw new RuntimeException("Exception in CompletableFuture!");
    }
    return "No exception";
}).exceptionally(ex -> {
    System.out.println("Handled exception: " + ex);
    return "Recovered value";
}).thenAccept(System.out::println);

---

Saya harap artikel ini memberi anda titik permulaan yang baik untuk meneroka kelas CompletableFuture dengan lebih lanjut.

Pautan Berguna:

• Concurrency Deep Dives: Panduan untuk CompletableFuture
• Pengenalan Komprehensif kepada Pengaturcaraan Asynchronous di Java — Janji, Panggilan Balik dan Masa Hadapan

Atas ialah kandungan terperinci Minggu Ini Saya Belajar: CompletableFuture – Pendekatan Java untuk Pengaturcaraan Asynchronous. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!