CKTIS / Java
ForkJoinTask — berekeningen opsplitsen en resultaten combineren
ForkJoinTask vertegenwoordigt een taak die door ForkJoinPool wordt uitgevoerd. Leer aan de hand van een voorbeeld dat een som opsplitst in deeltaken hoe je met fork() taken plant, met join() resultaten ophaalt en met invokeAll() een groep taken uitvoert.
Versie: Java SE 21; repository runtime, production runtime not attested
Syntax
ForkJoinTask<V> task;
ForkJoinTask<V> scheduled = task.fork();
V result = task.join();
ForkJoinTask.invokeAll(task1, task2);ForkJoinTask<V> is een abstracte taak voor ForkJoinPool. Voor berekeningen die een resultaat opleveren, breid je meestal RecursiveTask<V> uit en implementeer je compute(). De pool deelt threads tussen taken; een taak betekent niet dat er een aparte thread wordt aangemaakt.
ForkJoinTask.fork() plant de uitvoering in de huidige pool of, buiten een pool, in ForkJoinPool.commonPool(). ForkJoinTask.join() wacht op het resultaat; deze methode gooit geen InterruptedException en geeft fouten door als ongecontroleerde uitzonderingen.
ForkJoinTask.invokeAll() start een groep taken en wacht tot ze zijn voltooid of tot er een uitzondering optreedt. Na een uitzondering kunnen andere taken worden geannuleerd; het is niet gegarandeerd dat alle taken worden voltooid. Haal resultaten op met join().
Vermijd blokkerende I/O en cyclische afhankelijkheden tussen taken. In het voorbeeld start pool.invoke(root) de berekening in een aparte pool. Sum splitst een bereik in tweeën, berekent één helft lokaal en combineert de resultaten; invokeAll() coördineert de twee delen. De lage splitsingsdrempel is bedoeld als demonstratie, niet om prestaties te meten.
Voorbeelden
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
public class Main {
static final class Sum extends RecursiveTask<Integer> {
private final int from;
private final int to;
Sum(int from, int to) {
this.from = from;
this.to = to;
}
@Override
protected Integer compute() {
if (to - from <= 2) {
int total = 0;
for (int i = from; i < to; i++) {
total += i;
}
return total;
}
int mid = from + (to - from) / 2;
Sum left = new Sum(from, mid);
Sum right = new Sum(mid, to);
left.fork();
int rightResult = right.compute();
return left.join() + rightResult;
}
}
public static void main(String[] args) {
try (ForkJoinPool pool = new ForkJoinPool(2)) {
ForkJoinTask<Integer> root = new RecursiveTask<Integer>() {
@Override
protected Integer compute() {
Sum first = new Sum(1, 5);
Sum second = new Sum(5, 9);
ForkJoinTask.invokeAll(first, second);
return first.join() + second.join();
}
};
System.out.println(pool.invoke(root));
}
}
}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.