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.