ForkJoinPool yordamida massiv elementlarining yig'indisini parallel hisoblash uchun qanday usullar mavjud?

ForkJoinPool yordamida massiv elementlarining yig'indisini parallel hisoblash uchun, massivni bo'laklarga bo'lib, ularni parallel tarzda yig'adigan rekursiv vazifa amalga oshirilishi mumkin.

Asosiy g'oya:

• Agar kichik bo'lak bo'lsa, yig'indini to'g'ridan-to'g'ri hisoblaymiz.
• Aks holda, bo'lakni ikkiga bo'lamiz, ikkita kichik vazifa yaratamiz, ularni parallel ishga tushiramiz va natijalarni birlashtiramiz.

Java'da RecursiveTask<Integer> bilan misol:

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(); // chap vazifa asinxron boshlanadi
            int rightResult = rightTask.compute(); // o'ng vazifa hozirgi ipda hisoblanadi
            int leftResult = leftTask.join(); // chap vazifaning natijasini kutamiz
            return leftResult + rightResult;
        }
    }
}

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

Ushbu yondashuv katta massivlarning yig'indisini hisoblashda ko'p ipli ishlashdan samarali foydalanadi.