Clase Java.util.concurrent.RecursiveTask en Java con ejemplos

RecursiveTask es una clase abstracta que encapsula una tarea que devuelve un resultado. Es una subclase de ForkJoinTask . La clase RecursiveTask se amplía para crear una tarea que tiene un tipo de devolución particular. El código que representa la parte computacional de la tarea se mantiene dentro del método compute() de RecursiveTask.

La clase RecursiveTask se usa principalmente en el contexto de la programación paralela. Las tareas que se pueden dividir en subtareas independientes y el resultado final de la tarea se puede obtener a partir de los resultados de la subtarea, se pueden implementar de manera más eficiente utilizando RecursiveTask. Por ejemplo, buscar un elemento en una array grande.

Jerarquía de clases

java.lang.Object
↳ java.util.concurrent.ForkJoinTask
  ↳ java.util.concurrent.RecursiveTask<V>

Constructor

1. RecursiveTask() : crea un objeto de RecursiveTask con la configuración predeterminada.

   public RecursiveTask()
   

Métodos

1. compute() : el método que define la tarea.

   protected abstract void compute()
   

2. exec() : este método implementa las reglas básicas necesarias para la ejecución de una tarea.

   protected final boolean exec()
   

3. getRawResult() : la función devuelve el valor obtenido después de completar la tarea, incluso si la tarea se completa de manera anormal. Devuelve nulo, si la tarea aún no se ha completado.

   public final Void getRawResult()
   

4. setRawResult() : la función establece el valor de retorno de la tarea en el valor pasado en el argumento.

   protected final void setRawResult(Void mustBeNull)
   

Ejemplo para demostrar RecursiveTask

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
  
public class RecursiveTaskDemo {
    public static void main(String[] args)
    {
        ForkJoinPool fjp = new ForkJoinPool();
  
        double[] nums = new double[5000];
        for (int i = 0; i < nums.length; i++) {
            nums[i] = (double)(((i % 2) == 0) ? i : -1);
        }
        Sum task = new Sum(nums, 0, nums.length);
        double summation = fjp.invoke(task);
        System.out.println("Summation " + summation);
    }
}
  
class Sum extends RecursiveTask<Double> {
    final int seqThreshold = 500;
    double[] data;
    int start, end;
  
    Sum(double[] data, int start, int end)
    {
        this.data = data;
        this.start = start;
        this.end = end;
    }
  
    @Override
    protected Double compute()
    {
        double sum = 0;
        if ((end - start) < seqThreshold) {
            for (int i = start; i < end; i++)
                sum += data[i];
        }
        else {
            int middle = (start + end) / 2;
  
            Sum subtaskA = new Sum(data, start, middle);
            Sum subtaskB = new Sum(data, middle, end);
  
            subtaskA.fork();
            subtaskB.fork();
  
            sum += subtaskA.join() + subtaskB.join();
        }
        return sum;
    }
}

Summation 6245000.0

Referencia: https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/RecursiveTask.html