CKTIS / Java
RecursiveTask — een recursieve taak met resultaat
RecursiveTask<V> stelt een fork/join-taak voor die een resultaat van het type V teruggeeft. De methode compute() beschrijft de berekening: los een klein probleem direct op of splits het op in subtaken en combineer hun resultaten.
Versie: Java SE 21; repository runtime, production runtime not attested
Syntax
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> is een abstracte klasse uit java.util.concurrent die ForkJoinTask<V> uitbreidt. De klasse ondersteunt verdeel-en-heersberekeningen die een resultaat van het type V teruggeven. Voor taken zonder resultaat is RecursiveAction het equivalent.
RecursiveTask.compute heeft de signatuur protected abstract V compute(). Een subklasse implementeert het basisgeval en de verdeling van het werk. Een directe aanroep van compute() is een gewone methodeaanroep: de taak wordt niet bij een pool ingediend. In het voorbeeld start pool.invoke(...) de hoofdtaak en geeft het resultaat terug.
Een gebruikelijk patroon is left.fork(), een directe aanroep van right.compute() en daarna left.join(). fork() regelt asynchrone uitvoering; join() wacht indien nodig en geeft het resultaat terug. Dit betekent niet dat er voor elke taak een aparte thread is. Wachtende afhankelijkheden moeten acyclisch zijn om deadlocks te voorkomen.
Het voorbeeld telt disjuncte bereiken [from, to) op zonder de array te wijzigen. De drempel 2 laat het opsplitsen zien, maar is geen aanbeveling voor prestaties: te kleine taken verhogen de overhead. Vermijd blokkerende I/O in deze berekeningen. De code is bedoeld voor Java SE 21; compatibiliteit met een productie-runtime is niet bevestigd.
Voorbeelden
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)));
}
}
}Resultaat
36
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.