CKTIS / Java
ForkJoinTask — suddividere i calcoli e combinare i risultati
ForkJoinTask rappresenta un’attività eseguita da ForkJoinPool. Scopri, con un esempio che suddivide una somma in sottoattività, come pianificare con fork(), recuperare i risultati con join() ed eseguire un gruppo di attività con invokeAll().
Versione: Java SE 21; repository runtime, production runtime not attested
Sintassi
ForkJoinTask<V> task;
ForkJoinTask<V> scheduled = task.fork();
V result = task.join();
ForkJoinTask.invokeAll(task1, task2);ForkJoinTask<V> è un’attività astratta per ForkJoinPool. Per i calcoli che restituiscono un risultato, in genere si estende RecursiveTask<V> e si implementa compute(). Il pool condivide i thread tra le attività; un’attività non implica un thread separato.
ForkJoinTask.fork() pianifica l’esecuzione nel pool corrente oppure, se non ci si trova in un pool, in ForkJoinPool.commonPool(). ForkJoinTask.join() attende il risultato; non genera InterruptedException e propaga gli errori come eccezioni non controllate.
ForkJoinTask.invokeAll() avvia un gruppo di attività e attende il completamento o un’eccezione. Dopo un’eccezione, le altre attività possono essere annullate; non è garantito che tutte terminino. Recupera i risultati con join().
Evita l’I/O bloccante e le dipendenze cicliche tra attività. Nell’esempio, pool.invoke(root) avvia il calcolo in un pool dedicato. Sum divide un intervallo a metà, calcola localmente una metà e combina i risultati; invokeAll() coordina le due parti. La piccola soglia di suddivisione serve a fini dimostrativi, non alla misurazione delle prestazioni.
Esempi
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));
}
}
}Risultato
36
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.