Parallel Programming in Java

In this article, we are going to learn about a topic known as Parallel Programming. Throughout this article, we will learn why Parallel Programming is used in Java and where it is used. This helps us understand the importance of Parallel Programming and how different it is from multithreading.

What is Parallel Programming in Java?

Parallel Programming is a process of breaking down a complex problem into smaller and simpler tasks, which can be executed at the same time using a number of computer resources. In the process of Parallel Programming, the tasks which are independent of each other are executed parallelly using different computers or multiple crores present in a CPU of a computer. Parallel Programming is an essential necessity for firms to handle heavy and large-scale projects as they need to maintain their economic standards. Due to Parallel Programming, the speed of the project is increased, and its probability of error is decreased.

Parallel Programming is quite different from multithreading as its tasks have no need to follow an order of execution. Each task of Parallel Programming is designed according to the function they need to perform. Hence it is widely known as Functional Parallelism or Data Parallelism.

Why is Parallel Programming used?

As multicore CPU's advanced in recent times, efficient programming at their maximum can be achieved by implementing Parallel Programming. Basically, Parallel Programming refers to the parallel execution of processes due to the availability of multiple resources such as processing cores. Parallel Programming is considered to be a much more efficient method than multithreading. The parallel tasks which are solved simultaneously are combined to give the final solution to a larger problem.

The Java Standard Environment ( Java SE) provides a programmer with the " Fork/Join Framework ". The Fork/Join Framework helps a programmer to implement Parallel Programming easily in their applications. But the complexity which arises with Fork/Join framework is that the programmer is the one who needs to specify how the program is divided into tasks. Using aggerate operations, the Java runtime will perform this dividing for us.

The Fork/Join Framework in Java SE:

java.util.concurrent is the package which is responsible for defining the Fork/Join Framework in Java. The java.util.concurrent package contains various classes and interfaces which help us in achieving Parallel Programming using the Java Programming Language. In Parallel Processing, the processing part is optimized for the use of multiple processors at the same time. When it comes to multithreading, the idle time of a single CPU is optimized based on the shared time. The partitioned tasks of a large program are wrapped in a ForkJoinTask subclass by making use of its abstract tasks. The two abstract tasks of a Fork/Join subclass are " Recursive Task " and " RecursiveAction ".

The Fork/Join Framework uses a strategy based on the divide and conquers rule to achieve Parallel Processing. In this process, a huge task is divided into small tasks, which are again divided into simpler tasks. In this way, each task is reduced to smaller tasks until they are small enough to be handled sequentially.

Classes of the Fork/Join Framework:

Recursive Task: It is useful when we wish to return a result from our task. For example, while sorting a huge array, the result of each of the sub-tasks is needed to be compared with each other. This abstract task is a complex task which makes it harder to code.
RecursiveAction: It is useful when we desire not to return any result from the program. For example, if we wish to initialize a large array with custom values to it, then every subtask works alone on its own piece of the array. A new class is created in order to use the RecursiveAction.
The class which we create acts as a child class which extends from java.util.Concurrent.RecursiveAction. A new instance of RecursiveAction must be implemented to call the RecursiveAction. The newly created instance of RecursiveAction will be invoked by using the ForkJoinPool.
ForkJoinTask: The ForkJoinTask is an abstract class which is used to define a task. Basically, a task can be created with the help of the fork() method belonging to this abstract class. This task is lighter than a thread that is created using the Thread class.
ForkJoinPool: The ForkJoinPool class provides us with a common pool which helps us in the execution of the task of ForkJoinTask.

Methods of the Fork/Join Framework:

Compute(): A recursive call is done when we call the compute() method on the right task.
Fork(): When the fork() method is used, our newly constructed PrimeRecursiveAction is added to the list of tasks for the active thread.
Join(): when we call the join() method on a forked task, it should be one of the last steps after using other methods.

Let us see an example program to implement the Parallel Programming concept using the Fork/Join framework in Java Programming.

Program to Implement Parallel Programming:

import java.util.concurrent.RecursiveAction;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.TimeUnit;
public class parallelsExample extends RecursiveAction
{
    final int TH = 2;
    double[] numbers;
    int inStart, inLast;
    
    parallelsExample
 (double[]n, int x, int l)
    {
        numbers = n;
        inStart = x;
        inLast = l;
    }
    
    protected void computing ()
    {
        if ((inLast - inStart) > TH)
            for (int i = inStart; i < inLast; i++)
             numbers[i] = numbers[i] + Math.random ();
        else
            invokeAll (new parallelsExample
         (numbers,
           inStart,
           (inStart - inLast) / 2),
   new parallelsExample
 (numbers, (inStart - inLast) / 2,
           inLast));
    }
    public static void main (String[]args)
    {
        final int SIZE = 10;
        ForkJoinPool pool = new ForkJoinPool ();
        double na[] = new double[SIZE];
        System.out.println ("The Initialized Random Values Are :");
        for (int i = 0; i < na.length; i++)
        {
            na[i] = (double) i + Math.random ();
            System.out.format ("%.4f ", na[i]);
        }
        System.out.println ();
        parallelsExample
     task = new parallelsExample
     (na, 0, na.length);
        pool.invoke (task);
        System.out.println (" The Changed Values Are :");
        for (int i = 0; i < 10; i++)
            System.out.format ("%.4f ", na[i]);
        System.out.println ();
    }

    @Override
    protected void compute() {
        // TODO Auto-generated method stub
        
    }
}

Output:

The Initialized Random Values Are :
0.22471.72022.8929 3.4130 4.6356 5.01256.7087 7.1517 8.8097 9.4126 
 The Changed Values Are :
0.2247 1.7202 2.8929 3.4130 4.63565.0125 6.7087 7.15178.8097 9.4126