Milliste meetoditega saab ForkJoinPool abil massivi elementide summa arvutamist paralleelselt rakendada?

Paralleelne elementide summa arvutamiseks massiivis kasutades ForkJoinPool'i, saab rakendada rekursiivset ülesannet, mis jagab massiivi osadeks ja arvutab nende summa paralleelselt.

Põhiteooria:

• Kui alam-massiivi suurus on väike, arvutame summa otse.
• Vastasel juhul jagame alam-massiivi kaheks osaks, loome kaks ülesannet, täidame need paralleelselt ja ühendame tulemused.

Näide Java keeles kasutades RecursiveTask<Integer>:

import java.util.concurrent.*;

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

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

    @Override
    protected Integer compute() {
        int length = end - start;
        if (length <= THRESHOLD) {
            int sum = 0;
            for (int i = start; i < end; i++) {
                sum += array[i];
            }
            return sum;
        } else {
            int mid = start + length / 2;
            SumTask leftTask = new SumTask(array, start, mid);
            SumTask rightTask = new SumTask(array, mid, end);
            leftTask.fork(); // käivitame vasaku ülesande asünkroonselt
            int rightResult = rightTask.compute(); // arvutame parema ülesande praeguses lõimes
            int leftResult = leftTask.join(); // ootame vasaku ülesande tulemust
            return leftResult + rightResult;
        }
    }
}

// Kasutamine:
// ForkJoinPool pool = new ForkJoinPool();
// int[] data = ...;
// int totalSum = pool.invoke(new SumTask(data, 0, data.length));

Selline lähenemine kasutab tõhusalt mitme protsessori võimalusi, kiirendades suure massiivi summat.