Cara menggunakan CompletableFuture untuk pengaturcaraan tak segerak dan kawalan konkurensi dalam Java 9

Cara menggunakan CompletableFuture untuk melaksanakan pengaturcaraan asynchronous dan kawalan concurrency dalam Java 9

Pengenalan:
Dengan peningkatan permintaan untuk prestasi tinggi dan concurrency tinggi dalam aplikasi moden, pengaturcaraan tak segerak dan kawalan concurrency telah menjadi masalah biasa dalam pembangunan. Kelas CompletableFuture yang diperkenalkan dalam Java 9 menyediakan mekanisme yang berkuasa untuk mengendalikan operasi tak segerak dan menyediakan cara yang mudah dan elegan untuk melaksanakan kawalan serentak. Artikel ini akan memperkenalkan konsep asas CompletableFuture dalam Java 9 dan menyediakan beberapa kod sampel untuk menunjukkan cara menggunakan CompletableFuture untuk melaksanakan pengaturcaraan tak segerak dan kawalan konkurensi.

1. Pengenalan kepada CompletableFuture

CompletableFuture ialah tambahan kepada mekanisme pengaturcaraan tak segerak yang diperkenalkan di Java 8. Ia adalah kelas yang melaksanakan antara muka Future dan CompletionStage. Antara muka Masa Depan digunakan untuk mewakili hasil tugas tak segerak yang mungkin tidak selesai, manakala antara muka CompletionStage digunakan untuk menyatakan pengiraan yang mungkin dilakukan secara tak segerak (termasuk operasi mencetuskan dan mengembalikan hasil), dan operasi seterusnya yang mungkin dicetuskan. selepas pengiraan selesai. Kelas CompletableFuture menyediakan cara yang mudah untuk menggunakan antara muka ini dan menyediakan keupayaan yang lebih berkuasa untuk mengendalikan operasi tak segerak.

2. Contoh penggunaan asas

1. Mencipta objek CompletableFuture

Pertama, kita perlu mencipta objek CompletableFuture untuk mewakili hasil pengiraan tak segerak. Kelas CompletableFuture menyediakan pelbagai kaedah statik untuk mencipta objek sedemikian, seperti completeFuture, supplyAsync, dsb. Berikut ialah contoh kod:

CompletableFuture<String> future = CompletableFuture.completedFuture("Hello, CompletableFuture!");

Dalam kod di atas, kami menggunakan kaedah completeFuture untuk mencipta objek CompletableFuture yang lengkap dan menghantarnya rentetan sebagai hasil pengiraan.

2. Cetuskan pengiraan tak segerak

Seterusnya, kita perlu mencetuskan pengiraan tak segerak dan mengaitkannya dengan objek CompletableFuture yang dicipta dalam langkah sebelumnya. Kelas CompletableFuture menyediakan dua kaedah untuk mencapai ini, iaitu runAsync dan supplyAsync. Yang pertama digunakan untuk melakukan operasi tak segerak yang tidak mengembalikan hasil, manakala yang terakhir digunakan untuk melakukan operasi tak segerak yang mengembalikan hasil. Berikut ialah contoh kod:

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 异步计算，返回一个整数结果
    return 42;
});

Dalam kod di atas, kami menggunakan kaedah supplyAsync untuk mencipta pengiraan yang dilaksanakan secara tak segerak yang akan mengembalikan hasil integer.

3. Memproses keputusan pengiraan tak segerak

Setelah pengiraan tak segerak selesai, kita boleh memproses keputusan yang dikira dengan memanggil kaedah objek CompletableFuture. Kelas CompletableFuture menyediakan pelbagai kaedah untuk memproses hasil, seperti thenApply, thenAccept, dsb. Berikut ialah contoh kod:

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 异步计算，返回一个整数结果
    return 42;
});
future.thenApply(result -> {
    // 处理结果并返回一个新的结果
    return result * 2;
})
.thenAccept(result -> {
    // 处理最终结果
    System.out.println("Final result: " + result);
});

Dalam kod di atas, kami memanggil kaedah thenApply untuk memproses keputusan selepas pengiraan tak segerak selesai, dan mengembalikan hasil baharu. Kemudian, kami memanggil kaedah thenAccept untuk memproses hasil akhir dan mencetaknya.

3. Contoh kawalan Concurrency

Selain pengaturcaraan asynchronous, CompletableFuture juga menyediakan beberapa kaedah untuk melaksanakan kawalan concurrency. Kaedah yang paling biasa digunakan termasuk: anyOf, allOf dan join.

1. anyOf kaedah

anyOf kaedah digunakan untuk menunggu mana-mana satu daripada berbilang CompletableFutures selesai. Ia akan mengembalikan objek CompletableFuture baharu yang menilai kepada hasil objek CompletableFuture yang pertama selesai. Berikut ialah contoh kod:

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    // 异步计算1
    return 1;
});
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    // 异步计算2
    return 2;
});
CompletableFuture<Object> resultFuture = CompletableFuture.anyOf(future1, future2);
resultFuture.thenAccept(result -> {
    System.out.println("First result: " + result);
});

Dalam kod di atas, kami menggunakan kaedah anyOf untuk menunggu sama ada future1 atau future2 dikira dan mencetak hasilnya. Kaedah

2. allOf

allOf kaedah digunakan untuk menunggu semua pengiraan dalam berbilang CompletableFutures selesai. Ia akan mengembalikan objek CompletableFuture baharu, yang menilai kepada nilai Void (null). Berikut ialah contoh kod:

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    // 异步计算1
    return 1;
});
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    // 异步计算2
    return 2;
});
CompletableFuture<Void> resultFuture = CompletableFuture.allOf(future1, future2);
resultFuture.thenRun(() -> {
    System.out.println("All calculations are completed.");
});

Dalam kod di atas, kami menggunakan kaedah allOf untuk menunggu semua pengiraan pada masa hadapan1 dan masa hadapan2 untuk melengkapkan dan mencetak mesej selesai.

3. kaedah join

kaedah join digunakan untuk menunggu keputusan pengiraan CompletableFuture dan mengembalikan hasilnya. Jika pengecualian berlaku semasa pengiraan, pengecualian akan dilemparkan. Berikut ialah contoh kod:

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 异步计算，返回一个整数结果
    return 42;
});
int result = future.join();
System.out.println("Result: " + result);

Dalam kod di atas, kami menggunakan kaedah join untuk menunggu pengiraan masa hadapan selesai dan mendapatkan hasilnya.

Ringkasan:

Artikel ini memperkenalkan konsep asas CompletableFuture dalam Java 9 dan memberikan beberapa contoh kod untuk menunjukkan cara menggunakan CompletableFuture untuk melaksanakan pengaturcaraan tak segerak dan kawalan konkurensi. Dengan menggunakan CompletableFuture, kami boleh mengendalikan operasi tak segerak dengan cara yang mudah dan elegan serta mencapai kawalan fleksibel bagi pengiraan serentak. Saya harap contoh ini akan membantu anda memahami dan menggunakan CompletableFuture.

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