java.util.concurrent.RecursiveAction class in Java With Examples

The RecursiveAction class is used just for jobs that don't return any results and is an abstract subclass of the java.util.concurrent.ForkJoinTask. In order to signal that the job does not provide a result, it extends the java.lang.Void class.

Tasks that can be separated and can have concurrent execution are begin handled by the RecursiveAction. RecursiveAction, for instance, makes it simple to sort large arrays by splitting them up into smaller, and more manageable chunks and sorting each one of them on a different core.

Key Features and Methods

Fork(), join(), and call() are just a few of the helpful methods that RecursiveAction has inherited as it is a subclass of ForkJoinTask. These techniques make it possible for the work to be carried out in a Fork/Join pool, allowing for effective parallel execution.

Recursive Execution: The compute() method in RecursiveAction is the main method that needs to be implemented. It defines the computation that needs to be performed for a particular task. This method can divide the task into smaller subtasks, invoke them using fork(), and then combine the results using join().

Recursive Termination: To prevent an infinite recursive loop, the compute() method should include a termination condition. This condition checks whether the task has become small enough to be solved sequentially. If the termination condition is met, the task can directly perform its computation without further recursion.

Example

Recursive Termination: To prevent an infinite recursive loop, the compute() method should include a termination condition. The condition checks whether the task has become small enough to be solved sequentially. If the termination condition is met, the task can directly perform its computation without further recursion.

To illustrate the usage of RecursiveAction, let's consider an example of calculating the sum of an array of integers. We can divide the array into smaller subarrays, calculate the sum of each subarray concurrently, and then combine the results to obtain the final sum.

Filename: RecursiveActionClass.java

import java.util.concurrent.RecursiveAction;
import java.util.concurrent.ForkJoinPool;

public class RecursiveActionClass 
{
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        SumTask sumTask = new SumTask(array, 0, array.length);

        ForkJoinPool forkJoinPool = new ForkJoinPool();
        forkJoinPool.invoke(sumTask);

        int sum = sumTask.result;
        System.out.println("Sum: " + sum);
    }

    static class SumTask extends RecursiveAction {
        private static final int THRESHOLD = 1000;
        private int[] array;
        private int start;
        private int end;
        private int result;

        public SumTask(int[] array, int start, int end) {
            this.array = array;
            this.start = start;
            this.end = end;
        }

        @Override
        protected void compute() {
            if (end - start <= THRESHOLD) {
                result = computeSequentially();
            } else {
                int mid = (start + end) / 2;
                SumTask leftTask = new SumTask(array, start, mid);
                SumTask rightTask = new SumTask(array, mid, end);

                leftTask.fork();
                rightTask.compute();
                leftTask.join();

                result = leftTask.result + rightTask.result;
            }
        }

        private int computeSequentially() {
            int sum = 0;
            for (int i = start; i < end; i++) {
                sum += array[i];
            }
            return sum;
        }
    }
}

Output:

Sum: 55

In this illustration, the compute() method is overridden by the SumTask class, which inherits RecursiveAction. The job uses the computeSequentially() function to sequentially calculate the sum if the array's size is less than or equal to the threshold value. If not, it splits the task into two smaller ones and recursively calculates the sum of each one. In order to arrive at the final amount, it finally integrates the outcomes of both subtasks.

To use the SumTask class, we can create an instance of it and invoke the invoke() method on it as follows:

Filename: RecursiveTaskClass.java

import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;

public class RecursiveTaskClass {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        SumTask sumTask = new SumTask(array, 0, array.length);

        ForkJoinPool forkJoinPool = new ForkJoinPool();
        int sum = forkJoinPool.invoke(sumTask);

        System.out.println("Sum: " + sum);
    }

    static class SumTask extends RecursiveTask<Integer> {
        private static final int THRESHOLD = 1000;
        private int[] array;
        private int start;
        private int end;

        public SumTask(int[] array, int start, int end) {
            this.array = array;
            this.start = start;
            this.end = end;
        }

        @Override
        protected Integer compute() {
            if (end - start <= THRESHOLD) {
                return computeSequentially();
            } else {
                int mid = (start + end) / 2;
                SumTask leftTask = new SumTask(array, start, mid);
                SumTask rightTask = new SumTask(array, mid, end);

                leftTask.fork();
                int rightResult = rightTask.compute();
                int leftResult = leftTask.join();

                return leftResult + rightResult;
            }
        }

        private int computeSequentially() {
            int sum = 0;
            for (int i = start; i < end; i++) {
                sum += array[i];
            }
            return sum;
        }
    }
}

Output:

Sum: 55

In this example, the SumTask class now extends RecursiveTask<Integer> instead of RecursiveAction. The compute() method returns an Integer value instead of void, and the computation logic is adjusted accordingly. The result of forkJoinPool.invoke(sumTask) is now assigned to the sum variable directly.

In Java, the RecursiveAction class is part of the java.util.concurrent package and is used for creating recursive tasks that do not return a result. It is typically used in conjunction with the Fork/Join framework for parallel computing.

Methods

Here are some methods commonly used with the RecursiveAction class:

protected abstract void compute(): This method must be implemented by subclasses of RecursiveAction. It represents the computation that needs to be performed. It can be recursive in nature, where the task is divided into smaller subtasks.

protected void invokeAll(RecursiveAction... actions): This method can be used to invoke multiple recursive actions concurrently. It initiates the execution of the specified actions and waits for their completion.

protected abstract void setRawResult(Void value): This method is used to set the raw result of the computation. Since RecursiveAction does not return a result, the setRawResult() method is typically not used.

protected abstract Void getRawResult(): This method retrieves the raw result of the computation. As RecursiveAction does not return a result, the getRawResult() method is typically not used.

protected boolean computeInParallel(): This method is a hook that allows subclasses to control whether the computation should be divided into smaller subtasks and executed in parallel or not. By default, it returns true, indicating that the computation should be executed in parallel.

protected void setDone(): This method marks the task as completed. It is usually called when the computation has finished.

These are some of the common methods used with the RecursiveAction class. By extending this class and implementing the compute() method, you can create recursive tasks that can be executed in parallel using the Fork/Join framework.

Here's a complete example that includes the implementation of the methods mentioned earlier in Java:

File Name: MyRecursiveAction.java

import java.util.concurrent.RecursiveAction;

public class MyRecursiveAction extends RecursiveAction {

    private static final int THRESHOLD = 1;
    private int start;
    private int end;

    public MyRecursiveAction(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected void compute() {
        if (end - start <= THRESHOLD) {
            // Perform the computation here
            for (int i = start; i <= end; i++) {
                System.out.println("Processing: " + i);
            }
        } else {
            int mid = (start + end) / 2;
            // Divide the task into smaller subtasks
            MyRecursiveAction left = new MyRecursiveAction(start, mid);
            MyRecursiveAction right = new MyRecursiveAction(mid + 1, end);

            // Invoke the subtasks concurrently
            invokeAll(left, right);
        }
    }

    @Override
    protected void setRawResult(Void value) {
        // This method is not typically used for RecursiveAction
    }

    @Override
    protected Void getRawResult() {
        // This method is not typically used for RecursiveAction
        return null;
    }

    @Override
    protected boolean computeInParallel() {
        return true; // Allow parallel execution of subtasks
    }

    protected void setDone() {
        // Mark the task as completed
        super.setDone();
    }

    public static void main(String[] args) {
        MyRecursiveAction task = new MyRecursiveAction(1, 10);
        task.compute();
    }
}

Output:

Processing: 1
Processing: 2
Processing: 3
Processing: 4
Processing: 5
Processing: 6
Processing: 7
Processing: 8
Processing: 9
Processing: 10

Conclusion

A useful method for implementing parallel algorithms that adhere to the "divide-and-conquer" principle is provided by the RecursiveAction class in the java.util.concurrent package. The process of breaking a problem down into smaller subproblems and merging their results is made easier by it. Developers can take use of parallel processing capabilities and enhance the performance of their applications by utilising the RecursiveAction class and the Fork/Join framework.

Next TopicLargest Palindrome by Changing at Most K-digits in Java

← prev next →