Comment utiliser Future et Callable pour la programmation asynchrone en programmation simultanée Java ?

Utilisez Future et Callable pour la programmation asynchrone Java : Future encapsule le résultat de l'opération asynchrone et obtient la valeur de retour via la méthode get(). Callable est utilisé pour créer des tâches asynchrones, similaires à Runnable mais peuvent renvoyer une valeur. Dans l'exemple, une tâche appelable est créée et soumise au service exécuteur pour une exécution asynchrone. Le thread principal continue d'effectuer d'autres tâches et lorsque les résultats sont nécessaires, appelez Future.get() pour les obtenir. Arrêtez enfin le service exécuteur pour libérer des ressources.

Programmation asynchrone en Java Programmation simultanée utilisant Future et Callable

Introduction

La programmation asynchrone est une technique qui permet l'exécution simultanée de tâches sans bloquer le thread principal. En Java, la programmation asynchrone peut être implémentée à l'aide des interfaces Future et Callable.

Future

Future est l'encapsulation du résultat d'une opération asynchrone. Il est utilisé pour obtenir la valeur de retour d'une tâche, même si la tâche n'est pas encore terminée. Future fournit la méthode get(), qui renverra le résultat une fois la tâche terminée. get() 方法，当任务完成时，它将返回结果。

Callable

Callable 是一个用于创建异步任务的接口。它与 Runnable 接口类似，但是 Callable 可以返回一个值，而 Runnable 只能执行一个操作。

异步编程示例

下面是一个使用 Future 和 Callable 进行异步编程的示例：

import java.util.concurrent.*;

public class AsyncExample {

    public static void main(String[] args) {

        ExecutorService executorService = Executors.newSingleThreadExecutor();

        // 创建 Callable 任务，它将执行一个耗时的操作并返回结果
        Callable<Integer> task = () -> {
            // 模拟耗时的任务
            Thread.sleep(1000);
            return 42;
        };

        // 将 Callable 任务提交到执行器服务，它将异步执行任务
        Future<Integer> future = executorService.submit(task);

        // 主线程可以继续执行其他任务，而不必等待 Callable 任务完成
        System.out.println("Main thread is doing other work.");

        // 当需要结果时，可以调用 Future 的 get() 方法来获取它
        try {
            // 等待任务完成并获取结果
            Integer result = future.get();
            System.out.println("Result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            // 处理任务中断或执行异常
            e.printStackTrace();
        } finally {
            // 关闭执行器服务以释放资源
            executorService.shutdown();
        }
    }
}

在这个示例中：

• task 是一个 Callable 任务，它执行一个耗时的操作并返回结果。
• future 是一个 Future，它封装了 Callable 任务的结果。
• executorService 是一个执行器服务，它用于异步执行 Callable 任务。
• 主线程在提交任务后可以继续执行其他任务，无需等待任务完成。
• 当需要结果时，主线程可以调用 future.get()

Callable🎜🎜🎜Callable est une interface permettant de créer des tâches asynchrones. Elle est similaire à l'interface Runnable, mais Callable peut renvoyer une valeur, tandis que Runnable ne peut effectuer qu'une seule opération. 🎜🎜🎜Exemple de programmation asynchrone🎜🎜🎜Voici un exemple de programmation asynchrone utilisant Future et Callable : 🎜rrreee🎜Dans cet exemple : 🎜

• task est une tâche appelable, elle effectue une opération fastidieuse et renvoie le résultat. 🎜
• future est un Future qui encapsule le résultat de la tâche Callable. 🎜
• executorService est un service d'exécution, utilisé pour exécuter des tâches appelables de manière asynchrone. 🎜
• Le fil de discussion principal peut continuer à effectuer d'autres tâches après avoir soumis la tâche sans attendre que la tâche soit terminée. 🎜
• Lorsque le résultat est nécessaire, le thread principal peut appeler la méthode future.get() pour l'obtenir. 🎜🎜

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!