Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

RecursiveTask — une tâche récursive qui renvoie un résultat

RecursiveTask<V> représente une tâche fork/join qui renvoie un résultat de type V. Sa méthode compute() définit le calcul : traiter directement un petit problème, ou le diviser en sous-tâches et combiner leurs résultats.

Version : Java SE 21; repository runtime, production runtime not attested

Syntaxe

class Task extends RecursiveTask<Result> {
    @Override
    protected Result compute() {
        // Replace this placeholder with a base-case return or a return that combines subtask results.
        throw new UnsupportedOperationException("Implement compute()");
    }
}

RecursiveTask<V> est une classe abstraite du paquet java.util.concurrent qui étend ForkJoinTask<V>. Elle permet d’effectuer des calculs de type diviser pour régner qui renvoient un résultat de type V. Pour les tâches sans résultat, son équivalent est RecursiveAction.

RecursiveTask.compute a pour signature protected abstract V compute(). Une sous-classe implémente le cas de base et la division du travail. Appeler directement compute() est un appel de méthode ordinaire : cela ne soumet pas la tâche à un pool. Dans l’exemple, pool.invoke(...) lance la tâche principale et renvoie son résultat.

Un schéma courant consiste à appeler left.fork(), à exécuter directement right.compute(), puis à appeler left.join(). fork() organise l’exécution asynchrone ; join() attend si nécessaire et renvoie le résultat. Cela ne signifie pas qu’un thread distinct est créé pour chaque tâche. Les dépendances d’attente doivent être acycliques afin d’éviter les interblocages.

L’exemple additionne des plages disjointes [from, to) sans modifier le tableau. Le seuil 2 illustre le découpage, mais ne constitue pas une recommandation de performance : des tâches trop petites augmentent le surcoût. Évitez les opérations d’E/S bloquantes dans ces calculs. Le code cible Java SE 21 ; sa compatibilité avec un environnement d’exécution de production n’a pas été attestée.

Exemples

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class RecursiveTaskDemo {
    static final class SumTask extends RecursiveTask<Long> {
        private final int[] values;
        private final int from;
        private final int to;

        SumTask(int[] values, int from, int to) {
            this.values = values;
            this.from = from;
            this.to = to;
        }

        @Override
        protected Long compute() {
            if (to - from <= 2) {
                long sum = 0;
                for (int i = from; i < to; i++) {
                    sum += values[i];
                }
                return sum;
            }
            int mid = from + (to - from) / 2;
            SumTask left = new SumTask(values, from, mid);
            SumTask right = new SumTask(values, mid, to);
            left.fork();
            long rightSum = right.compute();
            return rightSum + left.join();
        }
    }

    public static void main(String[] args) {
        int[] values = {1, 2, 3, 4, 5, 6, 7, 8};
        try (ForkJoinPool pool = new ForkJoinPool(2)) {
            System.out.println(pool.invoke(new SumTask(values, 0, values.length)));
        }
    }
}

Résultat

36

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources