RecursiveAction es una clase abstracta que encapsula una tarea que no devuelve un resultado. Es una subclase de ForkJoinTask , que es una clase abstracta que representa una tarea que se puede ejecutar en un núcleo separado en un sistema multinúcleo. La clase RecursiveAction se amplía para crear una tarea que tiene un tipo de retorno nulo . El código que representa la parte computacional de la tarea se mantiene dentro del método compute() de RecursiveAction.
RecursiveAction se utiliza para tareas que se pueden dividir y ejecutar en paralelo. Estas tareas no deberían devolver ningún valor. Por ejemplo, la clasificación de una array grande se puede implementar fácilmente con RecursiveAction, dividiendo la array en pequeños fragmentos manejables y clasificando cada parte en un núcleo separado.
Jerarquía de clases
java.lang.Object ↳ java.util.concurrent.ForkJoinTask<Void> ↳ java.util.concurrent.RecursiveAction
Constructor de RecursiveAction:
- RecursiveAction : crea un objeto de RecursiveAction con la configuración predeterminada.
Sintaxis:
public RecursiveAction()
Métodos
- computar() : es el método que realiza el cálculo realizado por la tarea.
Sintaxis:
protected abstract void compute()
- exec() : este método implementa las reglas básicas necesarias para la ejecución de una tarea para RecursiveAction.
Sintaxis:
protected final boolean exec()
- getRawResult() : la función devuelve el estado de finalización de la tarea. Siempre devuelve nulo.
Sintaxis:
public final Void getRawResult()
- setRawResult() : la función establece el estado de finalización de la tarea en el valor pasado en el argumento.
Sintaxis:
protected final void setRawResult(Void mustBeNull)
Ejemplo : para demostrar la clase RecursiveAction
// Java program to demonstrate RecursiveAction Class
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
public class ForkJoinDemo {
public static void main(String[] args)
{
// Create a pool of threads.
ForkJoinPool fjp = new ForkJoinPool();
double[] nums = new double[100000];
// Give nums some values
for (int i = 0; i < nums.length; i++) {
nums[i] = (double)i;
}
System.out.println("A portion of the original sequence");
for (int i = 0; i < 9; i++) {
System.out.print(nums[i] + " ");
}
System.out.println();
SqrtTransform task
= new SqrtTransform(nums, 0, nums.length);
// Start the task
fjp.invoke(task);
System.out.println("A portion of the transformed sequence"
+ " (to four decimal places): ");
for (int i = 0; i < 9; i++) {
System.out.printf("%.4f ", nums[i]);
}
System.out.println();
}
}
// A task that transforms the elements into their square roots
class SqrtTransform extends RecursiveAction {
final int seqThreshold = 1000;
double[] data;
// Determines what part of data to process
int start, end;
SqrtTransform(double[] data, int start, int end)
{
this.data = data;
this.start = start;
this.end = end;
}
// The method where parallel computation will occur
@Override
protected void compute()
{
// If the number of elements are less
// than the sequential threshold
if ((end - start) < seqThreshold) {
for (int i = start; i < end; i++) {
data[i] = Math.sqrt(data[i]);
}
}
else {
// Otherwise, continue to break the data into smaller pieces
// Find the midpoint
int middle = (start + end) / 2;
// Invoke new tasks, using the subdivided tasks.
invokeAll(new SqrtTransform(data, start, middle),
new SqrtTransform(data, middle, end));
}
}
}
A portion of the original sequence 0.0 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 A portion of the transformed sequence (to four decimal places): 0.0000 1.0000 1.4142 1.7321 2.0000 2.2361 2.4495 2.6458 2.8284
Referencia: https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/RecursiveAction.html
Publicación traducida automáticamente
Artículo escrito por CharchitKapoor y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA