Parallel Programming in java

In parallel programming, a complex problem is broken down into simpler subtasks that can be executed simultaneously by multiple computational resources. This method is widely used by larger organizations and companies to handle advanced projects, ensuring higher efficiency and faster turnaround times. In Java, parallel programming is usually achieved by using Fork/Join framework.

The Fork/Join Framework

The Fork/Join option introduced in Java 7 is designed for work that can be repeatedly split into smaller chunks. It uses a collection of worker threads to steal jobs from each other, increasing CPU utilization.

How Fork/Join Framework Works

The framework follows a divide-and-conquer strategy:

• Fork: Divide the project into smaller subtasks.
• Join: Create subtasks and add them to the results.

Example: Sum of an Array

Let’s illustrate parallel programming in Java using the Fork/Join framework to compute the size of an array.

Step-by-Step Implementation

1. Create a Task Class: This class will extend `RecursiveTask<V>`, where `V` is the result type of the task.

2. Override compute() Method: If the task is too large, use the logic to divide it up or if it is small enough, calculate it directly.

3. Initialize and Invoke ForkJoinPool: Create an instance of `ForkJoinPool` and call the main function.

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

public class ParallelSum {

    // Custom task class for Fork/Join framework
    static class SumTask extends RecursiveTask<Long> {
        private static final int THRESHOLD = 1000; // Threshold for splitting tasks
        private int[] array;
        private int start, end;

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

        @Override
        protected Long compute() {
            if (end - start <= THRESHOLD) {
                // Direct computation if task is small enough
                long sum = 0;
                for (int i = start; i < end; i++) {
                    sum += array[i];
                }
                return sum;
            } else {
                // Split task if it's too large
                int mid = (start + end) / 2;
                SumTask leftTask = new SumTask(array, start, mid);
                SumTask rightTask = new SumTask(array, mid, end);

                // Fork left task
                leftTask.fork();
                // Directly compute right task and join results
                long rightResult = rightTask.compute();
                long leftResult = leftTask.join();

                return leftResult + rightResult;
            }
        }
    }

    public static void main(String[] args) {
        // Sample array
        int[] array = new int[10000];
        for (int i = 0; i < array.length; i++) {
            array[i] = i + 1;
        }

        // Create ForkJoinPool and invoke the main task
        ForkJoinPool pool = new ForkJoinPool();
        SumTask task = new SumTask(array, 0, array.length);
        long result = pool.invoke(task);

        // Print the result
        System.out.println("Sum: " + result);
    }
}

Sum: 50005000

Explanation

1. SumTask class:

• THRESHOLD: Specifies the time at which the job should be divided. If the range is below this threshold, it calculates the sum directly.
• compute(): directly compute the sum if the range is small enough. Otherwise, it splits the task into two subtasks, forks the left subtask and computes the right subtask.

2. Main Method:

• initializes an array with values ​​from 1 to 10000.
• Create a `ForkJoinPool` and call `SumTask`.
• The score prints the combination.

Benefits of Using Fork/Join Framework

1. Efficiency: Uses more CPU cores, resulting in faster execution.
2. Scalability: Can handle large data sets by breaking them down into manageable tasks.
3. Simplicity: Simplifies the implementation of parallel algorithms.

Conclusion

Parallel programming in Java using the Fork/Join framework is a powerful tool for improving performance in large projects. By breaking down tasks into smaller, parallelised tasks, you can fully utilize the computing power of your system, and maximize productivity The example provided illustrates a basic but flying use of this strategy effective, and lays the foundation for more robust parallel algorithms.