Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

ForkJoinTask — dividir cálculos y combinar resultados

ForkJoinTask representa una tarea ejecutada por ForkJoinPool. Aprende, con un ejemplo que divide una suma en subtareas, a planificar con fork(), obtener resultados con join() y ejecutar un grupo de tareas con invokeAll().

Versión: Java SE 21; repository runtime, production runtime not attested

Sintaxis

ForkJoinTask<V> task;
ForkJoinTask<V> scheduled = task.fork();
V result = task.join();
ForkJoinTask.invokeAll(task1, task2);

ForkJoinTask<V> es una tarea abstracta para ForkJoinPool. Para cálculos que devuelven un resultado, normalmente se extiende RecursiveTask<V> y se implementa compute(). El pool comparte los hilos entre las tareas; una tarea no implica que tenga un hilo independiente.

ForkJoinTask.fork() planifica la ejecución en el pool actual o, si no hay uno, en ForkJoinPool.commonPool(). ForkJoinTask.join() espera al resultado; no lanza InterruptedException y propaga los fallos como excepciones no comprobadas.

ForkJoinTask.invokeAll() inicia un grupo de tareas y espera a que terminen o a que se produzca una excepción. Tras una excepción, las demás tareas pueden cancelarse; no se garantiza que terminen todas. Obtén los resultados con join().

Evita las operaciones de E/S bloqueantes y las dependencias cíclicas entre tareas. En el ejemplo, pool.invoke(root) inicia el cálculo en un pool dedicado. Sum divide un intervalo en dos, calcula una mitad localmente y combina los resultados; invokeAll() coordina las dos partes. El pequeño umbral de división es para la demostración, no para medir el rendimiento.

Ejemplos

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));
        }
    }
}

Resultado

36

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes