L'utilisation d'ExecutorService et FutureTask dans la programmation parallèle Java

Utilisez ExecutorService pour gérer le pool de threads et exécuter des tâches, et utilisez FutureTask pour exécuter des tâches de manière asynchrone et récupérer leurs résultats. ExecutorService fournit des méthodes telles que execute() et submit(), et FutureTask fournit les méthodes get(), isDone() et Cancel(). Des exemples pratiques montrent comment les utiliser pour calculer en parallèle des nombres de la séquence de Fibonacci.

Utilisation d'ExecutorService et FutureTask dans la programmation parallèle Java

Introduction

ExecutorService et FutureTask sont des outils utiles pour la programmation parallèle en Java. ExecutorService vous permet de gérer un ensemble de threads, tandis que FutureTask vous permet d'exécuter des tâches de manière asynchrone et de récupérer leurs résultats.

ExecutorService

ExecutorService est une interface qui représente une collection de tâches de thread exécutables. Vous pouvez créer différentes implémentations d'ExecutorService en utilisant :

ExecutorService executorService = Executors.newFixedThreadPool(5);

où 5 représente le nombre de threads dans le pool de threads.

ExecutorService fournit les méthodes suivantes pour exécuter des tâches :

• execute(Runnable task) : exécute une tâche exécutable. execute(Runnable task)：执行一个 Runnable 任务。
• submit(Runnable task)：执行一个 Runnable 任务并返回值。
• submit(Callable<t> task)</t>：执行一个 Callable 任务并返回值。

FutureTask

FutureTask 是一个 Callable 任务的包装器，它允许您异步执行任务并稍后检索其结果。您可以使用以下方法创建 FutureTask：

FutureTask<String> futureTask = new FutureTask<>(() -> "Hello, world!");

其中，() -> "Hello, world!" 是要执行的 Callable 任务。

FutureTask 提供以下方法来检索任务结果：

• get()：阻塞等待任务完成并返回结果。
• isDone()：检查任务是否已完成。
• cancel(boolean mayInterruptIfRunning)
submit(Runnable task) : exécute une tâche Runnable et renvoie une valeur.

submit(Callable<t> task)</t> : exécute une tâche Callable et renvoie une valeur.

FutureTask

FutureTask est un wrapper autour d'une tâche appelable qui vous permet d'exécuter une tâche de manière asynchrone et de récupérer ses résultats plus tard. Vous pouvez créer une FutureTask en utilisant : 🎜

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

class FibonacciTask implements Callable<Long> {

    private int n;

    public FibonacciTask(int n) {
        this.n = n;
    }

    @Override
    public Long call() {
        long a = 0;
        long b = 1;
        for (int i = 0; i < n; i++) {
            long temp = a;
            a = b;
            b = temp + b;
        }
        return a;
    }
}

public class Main {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        FutureTask<Long>[] tasks = new FutureTask[10];

        // 创建并提交任务
        for (int i = 0; i < 10; i++) {
            tasks[i] = new FutureTask<>(new FibonacciTask(i));
            executorService.submit(tasks[i]);
        }

        // 获取并打印结果
        for (int i = 0; i < 10; i++) {
            try {
                System.out.println("斐波那契数列第 " + i + " 项：" + tasks[i].get());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        // 关闭 ExecutorService
        executorService.shutdown();
    }
}

🎜où () -> "Bonjour tout le monde !" est la tâche appelable à exécuter. 🎜🎜FutureTask fournit les méthodes suivantes pour récupérer les résultats de la tâche : 🎜🎜🎜get() : bloque l'attente de la fin de la tâche et renvoie le résultat. 🎜🎜isDone() : Vérifiez si la tâche est terminée. 🎜🎜cancel(boolean mayInterruptIfRunning) : Annulez la tâche (si possible). 🎜🎜🎜🎜Cas pratique🎜🎜🎜Considérons un programme qui calcule la séquence de Fibonacci. Nous pouvons utiliser ExecutorService et FutureTask pour calculer plusieurs nombres de Fibonacci en parallèle : 🎜rrreee🎜 Dans cet exemple, nous avons créé un ExecutorService et soumis 10 tâches FibonacciTask. Chaque tâche calcule un nombre dans la séquence de Fibonacci. Grâce à FutureTask, nous pouvons exécuter ces tâches de manière asynchrone et obtenir leurs résultats plus tard. 🎜

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!