Bagaimana untuk menggunakan Future dan CompletableFuture dalam fungsi Java concurrency dan multi-threading?

Future dan CompletableFuture ialah alat untuk concurrency dan multi-threading di Java. Masa hadapan mewakili hasil pengiraan tak segerak dan menyediakan kaedah get() untuk menyekat benang untuk mendapatkan hasilnya. CompletableFuture memanjangkan Masa Depan untuk menyediakan fungsi yang lebih kaya, seperti menggabungkan pengiraan, mengendalikan pengecualian dan menggunakan fungsi panggil balik.

Concurrency dan Multithreading dalam Fungsi Java: Menggunakan Future and CompletableFuture

Gambaran Keseluruhan

Future dan CompletableFuture adalah alatan serentak8 pengendalian yang diperkenalkan dalam Java synchronrons handling Mereka membenarkan anda melakukan operasi yang berjalan lama tanpa menyekat utas utama, meningkatkan prestasi aplikasi dan responsif.

Masa hadapan

Masa hadapan ialah objek yang mewakili hasil pengiraan tak segerak. Ia menyediakan kaedah get() yang menyekat urutan semasa sehingga hasilnya tersedia. Anda juga boleh menggunakan kaedah isDone() untuk menyemak sama ada pengiraan telah selesai. get()，用于阻塞当前线程直到结果可用。您还可以使用 isDone() 方法来检查计算是否完成。

CompletableFuture

CompletableFuture 是 Future 的扩展，提供了更丰富的功能。它允许您组合异步计算，处理异常，并使用回调函数。

实战案例

考虑以下示例，使用 Future 来异步加载文件：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class FileLoader {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Future<String> future = executorService.submit(() -> {
            // 异步加载文件
            return loadFile("file.txt");
        });

        // 继续执行其他任务，而不阻塞当前线程
        // ...

        // 当需要结果时，再阻塞主线程获取结果
        String result = future.get();
    }

    private static String loadFile(String filePath) {
        // 模拟文件加载操作
        return "File contents";
    }
}

在这个示例中，我们使用 ExecutorService 创建了一个线程池，然后使用 submit() 提交了一个异步任务，该任务负责加载文件。主线程继续执行其他任务，而不阻塞等待文件加载完成。最后，当需要文件内容时，我们再调用 get() 从 Future 中获取结果。

使用 CompletableFuture

以下示例展示了如何使用 CompletableFuture 来组合异步计算：

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {

    public static void main(String[] args) {
        // 定义第一个异步计算
        CompletableFuture<Integer> firstResult = CompletableFuture.supplyAsync(() -> {
            // 计算第一个结果
            return 5;
        });

        // 定义第二个异步计算
        CompletableFuture<Integer> secondResult = CompletableFuture.supplyAsync(() -> {
            // 计算第二个结果
            return 10;
        });

        // 组合两个计算，将它们的结果相加
        CompletableFuture<Integer> combinedResult = firstResult.thenCombine(secondResult, (x, y) -> x + y);

        // 获取最终结果
        int result = combinedResult.get();
    }
}

在这个示例中，我们使用 CompletableFuture#supplyAsync() 创建了两个异步计算。然后，我们使用 CompletableFuture#thenCombine() 将它们组合起来，将它们的结果相加。最后，我们使用 CompletableFuture#get()

CompletableFuture

🎜🎜CompletableFuture ialah lanjutan daripada Future, menyediakan fungsi yang lebih kaya. Ia membolehkan anda mengarang pengiraan tak segerak, mengendalikan pengecualian dan menggunakan fungsi panggil balik. 🎜🎜🎜Kes praktikal🎜🎜🎜Pertimbangkan contoh berikut menggunakan Future untuk memuatkan fail secara tidak segerak: 🎜rrreee🎜Dalam contoh ini, kami mencipta kumpulan benang menggunakan ExecutorService, Kemudian gunakan submit() untuk menyerahkan tugas tak segerak, yang bertanggungjawab untuk memuatkan fail. Benang utama terus melaksanakan tugas lain tanpa menyekat menunggu fail dimuatkan. Akhir sekali, apabila kandungan fail diperlukan, kami memanggil get() untuk mendapatkan hasil daripada Future. 🎜🎜🎜Menggunakan CompletableFuture🎜🎜🎜Contoh berikut menunjukkan cara menggunakan CompletableFuture untuk mengarang pengiraan tak segerak: 🎜rrreee🎜Dalam contoh ini, kami menggunakan CompletableFuture(#supply>to cipta Dua pengiraan tak segerak. Kami kemudian menggabungkannya menggunakan <code>CompletableFuture#thenCombine() untuk menambah keputusannya. Akhir sekali, kami menggunakan CompletableFuture#get() untuk mendapatkan hasil akhir. 🎜🎜Ringkasnya, Future dan CompletableFuture ialah alat berkuasa untuk mengendalikan operasi tak segerak dan tugas serentak. Gunakan alatan ini untuk meningkatkan prestasi dan responsif aplikasi anda, mencipta kod yang lebih cekap dan berskala. 🎜

Atas ialah kandungan terperinci Bagaimana untuk menggunakan Future dan CompletableFuture dalam fungsi Java concurrency dan multi-threading?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!