Comment utiliser Future et CompletableFuture dans la simultanéité des fonctions Java et le multi-threading ?

Future et CompletableFuture sont des outils de concurrence et de multi-threading en Java. Future représente le résultat du calcul asynchrone et fournit la méthode get() pour bloquer le thread afin d'obtenir le résultat. CompleteableFuture étend Future pour fournir des fonctionnalités plus riches, telles que la combinaison de calculs, la gestion des exceptions et l'utilisation de fonctions de rappel.

Concurrence et multithreading dans les fonctions Java : utilisation de Future et CompletableFuture

Vue d'ensemble

Future et CompletableFuture sont des outils de concurrence introduits dans Java 8 pour gérer les opérations asynchrones et les tâches simultanées. Ils vous permettent d'effectuer des opérations de longue durée sans bloquer le thread principal, améliorant ainsi les performances et la réactivité des applications.

Future

Future est un objet représentant le résultat d'un calcul asynchrone. Il fournit une méthode get() qui bloque le thread actuel jusqu'à ce que le résultat soit disponible. Vous pouvez également utiliser la méthode isDone() pour vérifier si le calcul est terminé. 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 est une extension de Future, offrant des fonctions plus riches. Il vous permet de composer des calculs asynchrones, de gérer des exceptions et d'utiliser des fonctions de rappel. 🎜🎜🎜Cas pratique🎜🎜🎜Considérons l'exemple suivant utilisant Future pour charger des fichiers de manière asynchrone : 🎜rrreee🎜Dans cet exemple, nous créons un pool de threads en utilisant ExecutorService, puis utilisons submit() pour soumettre une tâche asynchrone, responsable du chargement du fichier. Le thread principal continue d'effectuer d'autres tâches sans bloquer en attendant le chargement du fichier. Enfin, lorsque le contenu du fichier est nécessaire, nous appelons get() pour obtenir le résultat de Future. 🎜🎜🎜Utilisation de CompletableFuture🎜🎜🎜L'exemple suivant montre comment utiliser CompletableFuture pour composer des calculs asynchrones : 🎜rrreee🎜Dans cet exemple, nous utilisons CompletableFuture#supplyAsync() pour créer deux calculs asynchrones. Nous les combinons ensuite en utilisant CompletableFuture#thenCombine() pour ajouter leurs résultats. Enfin, nous utilisons CompletableFuture#get() pour obtenir le résultat final. 🎜🎜En bref, Future et CompletableFuture sont des outils puissants pour gérer les opérations asynchrones et les tâches simultanées. Utilisez ces outils pour améliorer les performances et la réactivité de votre application, en créant un code plus efficace et évolutif. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!