Mengendalikan Multithreading dalam Java dengan Masa Depan yang Boleh Dilengkapkan

1. Memahami Masa Depan yang Boleh Dilengkapi

CompletableFuture ialah sebahagian daripada pakej java.util.concurrent dan menawarkan cara untuk menulis kod tak segerak, tidak menyekat dengan cara yang lebih mudah dibaca dan diselenggara. Ia mewakili hasil masa hadapan pengiraan tak segerak.

1.1 Mencipta Masa Depan Lengkap yang Mudah

Untuk bermula dengan CompletableFuture , anda boleh mencipta tugas tak segerak yang mudah. Berikut ialah contoh:

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("Running asynchronously...");
            // Simulate a long-running task
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        future.join(); // Wait for the task to complete
        System.out.println("Task completed.");
    }
}

• CompletableFuture.runAsync() melaksanakan tugas secara tidak segerak.
• future.join() menyekat urutan utama sehingga tugasan selesai.

Keputusan Demo:

Running asynchronously...
Task completed.

1.2 Menggunakan CompletableFuture dengan Keputusan

Anda juga boleh menggunakan CompletableFuture untuk mengembalikan hasil daripada tugas tak segerak:

import java.util.concurrent.CompletableFuture;

public class CompletableFutureWithResult {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            // Simulate a computation
            return 5 * 5;
        });

        future.thenAccept(result -> {
            System.out.println("The result is: " + result);
        }).join();
    }
}

• CompletableFuture.supplyAsync() digunakan untuk tugasan yang mengembalikan hasil.
• thenAccept() memproses keputusan setelah pengiraan selesai.

Keputusan Demo:

The result is: 25

2. Menggabungkan Pelbagai Niaga Hadapan Lengkap

Mengendalikan berbilang tugas tak segerak ialah kes penggunaan biasa. CompletableFuture menyediakan beberapa kaedah untuk menggabungkan niaga hadapan.

2.1 Menggabungkan Niaga Hadapan dengan thenCombine

Anda boleh menggabungkan hasil daripada berbilang CompletableFutures :

import java.util.concurrent.CompletableFuture;

public class CombiningFutures {
    public static void main(String[] args) {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 5);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 10);

        CompletableFuture<Integer> combinedFuture = future1.thenCombine(future2, (result1, result2) -> result1 + result2);

        combinedFuture.thenAccept(result -> {
            System.out.println("Combined result: " + result);
        }).join();
    }
}

• thenCombine () menggabungkan keputusan dua masa hadapan.
• Hasil gabungan diproses menggunakan thenAccept ().

Keputusan Demo:

Combined result: 15

2.2 Mengendalikan Pelbagai Niaga Hadapan dengan allOf

Apabila anda perlu menunggu beberapa masa hadapan untuk diselesaikan, gunakan CompletableFuture.allOf():

import java.util.concurrent.CompletableFuture;

public class AllOfExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
            // Simulate task
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
            // Simulate another task
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        CompletableFuture<Void> allOfFuture = CompletableFuture.allOf(future1, future2);

        allOfFuture.join();
        System.out.println("All tasks completed.");
    }
}

• CompletableFuture.allOf() menunggu semua masa hadapan yang diberikan selesai.
• join() memastikan urutan utama menunggu sehingga semua tugasan selesai.

Keputusan Demo:

All tasks completed.

3. Ralat Pengendalian dengan CompletableFuture

Mengendalikan ralat adalah penting dalam pengaturcaraan tak segerak. CompletableFuture menyediakan kaedah untuk mengurus pengecualian.

3.1 Mengendalikan Pengecualian dengan luar biasa

Gunakan secara luar biasa () untuk mengendalikan pengecualian dalam tugas tak segerak:

import java.util.concurrent.CompletableFuture;

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            throw new RuntimeException("Something went wrong!");
        }).exceptionally(ex -> {
            System.out.println("Exception occurred: " + ex.getMessage());
            return null;
        });

        future.join();
    }
}

• luar biasa () menangkap dan mengendalikan pengecualian.
• Ia membolehkan anda memberikan hasil sandaran atau mengendalikan ralat.

Keputusan Demo:

Exception occurred: Something went wrong!

4. Kelebihan dan Kekurangan CompletableFuture

4.1 Kelebihan

• Pelaksanaan Asynchronous : Mengendalikan tugasan yang dijalankan serentak dengan cekap tanpa menyekat urutan utama.
• Kebolehbacaan Dipertingkat : Menyediakan cara yang lebih mudah dibaca dan diselenggara untuk mengendalikan kod tak segerak berbanding pendekatan panggil balik tradisional.
• API Kaya : Menawarkan pelbagai kaedah untuk menggabungkan, mengendalikan dan mengarang berbilang niaga hadapan.

4.2 Kelemahan

• Kerumitan : Walaupun berkuasa, CompletableFuture boleh memperkenalkan kerumitan dalam mengurus dan menyahpepijat kod tak segerak.
• Pengendalian Pengecualian: Mengendalikan pengecualian kadangkala boleh menjadi rumit, terutamanya dalam senario yang kompleks dengan berbilang peringkat.

5. Kesimpulan

Dalam panduan ini, kami telah meneroka cara CompletableFuture boleh digunakan untuk mengendalikan permintaan serentak dalam Java. Daripada mencipta tugas tak segerak yang mudah kepada menggabungkan berbilang masa hadapan dan ralat pengendalian, CompletableFuture menyediakan pendekatan yang teguh dan fleksibel kepada pengaturcaraan tak segerak.

Jika anda mempunyai sebarang pertanyaan atau memerlukan bantuan lanjut, sila tinggalkan komen di bawah. Saya berbesar hati untuk membantu!

Baca siaran lebih lanjut di : Mengendalikan Multithreading di Java dengan Masa Depan yang Boleh Dilengkapkan

Atas ialah kandungan terperinci Mengendalikan Multithreading dalam Java dengan Masa Depan yang Boleh Dilengkapkan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!