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

CKTIS / Java

RecursiveTask — una tarea recursiva que devuelve un resultado

RecursiveTask<V> representa una tarea fork/join que devuelve un resultado de tipo V. Su método compute() define el cálculo: resuelve directamente un problema pequeño o lo divide en subtareas y combina sus resultados.

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

Sintaxis

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> es una clase abstracta de java.util.concurrent que extiende ForkJoinTask<V>. Permite realizar cálculos de divide y vencerás que devuelven un resultado de tipo V. Para las tareas sin resultado, su equivalente es RecursiveAction.

RecursiveTask.compute tiene la firma protected abstract V compute(). Una subclase implementa el caso base y la división del trabajo. Llamar directamente a compute() es una llamada normal a un método: no envía la tarea a un pool. En el ejemplo, pool.invoke(...) inicia la tarea raíz y devuelve su resultado.

Un patrón habitual es left.fork(), una llamada directa a right.compute() y, después, left.join(). fork() organiza la ejecución asíncrona; join() espera si es necesario y devuelve el resultado. Esto no significa que haya un hilo distinto para cada tarea. Las dependencias de espera deben ser acíclicas para evitar interbloqueos.

El ejemplo suma rangos disjuntos [from, to) sin modificar el array. El umbral 2 muestra cómo dividir el trabajo, pero no es una recomendación de rendimiento: las tareas demasiado pequeñas aumentan la sobrecarga. Evita la E/S bloqueante en estos cálculos. El código está dirigido a Java SE 21; no se ha confirmado su compatibilidad con entornos de ejecución de producción.

Ejemplos

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

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